Notes on Recent Proofs
----------------------

These are informal notes on some of the recent proofs, updated as time
permits.

(7-Aug-2006) intab is one of the oddest "elementary" set theory theorems
I've seen.  It took a while to convince myself it was true before I
started to work out the proof, and the proof ended up rather long and
difficult for this kind of theorem.  Yet the only set theory axiom used
is Extensionality.  Perhaps I just have a mental block - if anyone sees
a simpler proof let me know.  I haven't seen this theorem in a book;
it arose as part of something else I'm working on.

Two new definitions were added to Hilbert space, df-0op and df-iop.
The expressions ( H~ X. 0H ) and ( I |` H~ ), which are equivalent to
them, have been used frequently enough to justify these definitions.


(4-Aug-2006) 3eqtrr, 3eqtr2, 3eqtr2r complete the 8 possibilities for 3
chained equalities, supplementing the existing 3eqtr, 3eqtr3, 3eqtr3r,
3eqtr4, 3eqtr4r.  I was disappointed that the 3 new ones reduce the size
of only 33 (compressed) proofs, taking away a total of 185 characters
from them, whereas the new theorems by themselves increase the database
size by 602 characters.  So, the database will grow by a net 417
characters, and the new ones don't "pay" for themselves.  Nonetheless,
O'Cat convinced me that they should be added anyway for completeness.
He wrote:

  I would vote for adding them even though the net change is PLUS 400 some
  bytes.

  It just makes unification via utilities like mmj2 much easier -- input
  the formula and let the program find a matching assertion.

  Esp. now that you've done the work to analyze them, it is illogical not
  to make the change:  eventually enough theorems will be added to save
  the added bytes.  And within 10 years when we have bigger, faster
  memories people would think it quaint to be so stingy with theorems that
  serve a valid purpose.

  We're going to have PC's with a minimum of 1GB RAM next year as
  standard, and that will just grow as the new nanotech advances.

So, I guess I should also complete the 3eqtr*d, 3bitr*, and 3bitr*d
families at some point.


(2-Aug-2006) fiint replaces fiintOLD.


(24-Jul-2006) Note that the description of today's sucxpdom says it has
"a proof using AC", and you can see in the list of axioms below the
proof that ax-ac was used.  Exercise:  How does ax-ac end up getting
used?

Metamath has no direct command to show you this, but it is usually easy
to find by examining the outputs of the following two commands:

1. show trace_back sucxpdom

  ... numth2 fodom fodomg fnrndomg ccrd($a) df-card($a) cardval cardon cardid
  cardne carden carddomi carddom cardsdom domtri entri entri2 sucdom unxpdomlem
  unxpdom
  ^^^^^^^

2. show usage ax-ac / recursive

  ...imadomg fnrndomg unidom unidomg uniimadom uniimadomf iundom cardval cardon
  cardid oncard cardne carden cardeq0 cardsn carddomi carddom cardsdom domtri
  entri entri2 entri3 sucdom unxpdomlem unxpdom unxpdom2 sucxpdom...
                                        ^^^^^^^

The theorem we want is the last theorem in the first list that appears
in the second list.  In this case, it is unxpdom.  And, indeed, we see
that unxpdom appears in proof step 43 of sucxpdom, and we can check that
unxpdom uses ax-ac for its proof.

Of course, there may be other theorems used by the sucxpdom proof that
require ax-ac, and the only way to determine that is to see if any of
the other theorems used in the sucxpdom proof appear in the second list.
But for a quick indication of what ax-ac is needed for, the method above
can be useful.


(21-Jul-2006) oev2, etc. are part of Mr. O'Cat's cleanup project for
some of the remaining *OLDs.


(20-Jul-2006) istps5 is important because it reassures us that our
definitions of Top and TopSp match exactly the standard textbook
version, even though the latter is more complex when the words are
converted to symbols.  I don't think istps5 will have an actual
practical use, though, because of the simpler theorems we have
available.


(18-Jul-2006) It is awkward to eliminate the "J e. V" hypothesis from
istop and isbasis/isbasis2 when it is redundant (as in most uses) - it
requires working with a dummy variable then elevating it to a class
variable with vtoclga - so I'm replacing these with "g" versions that
have "J e. V" as an antecedent (actually "J e. A" as customary, to allow
easy use of ibi when we need only the forward implication).  I think the
non-g versions will be used so rarely that it's not worth keeping them,
so they will be deleted, and it is trivial to use instead the "g"
version + ax-mp.  [Update:  istop, isbasis, and isbasis2 have now been
deleted.]

I also modified Stefan's 0opn, uniopn to use an antecedent instead
of hypothesis.

(17-Jul-2006) It is interesting that Munkres' definition of "a basis for
a topology" can be shortened considerably.  Compare
http://us2.metamath.org:8888/mpegif/isbasis3g.html (Munkres' version)
with http://us2.metamath.org:8888/mpegif/isbasisg.html (abbreviated
version).  Munkres' English-language definition is (p. 78):

  "Definition.  If X is a set, a _basis_ for a topology on X is a
  collection _B_ of subsets of X (called _basis elements_) such that

    (1) For each x e. X there is at least one basis element B containing x.

    (2) If x belongs to the intersection of two basis elements B1 and B2,
    then there is a basis element B3 containing x such that B3 (_ B1 i^i B2."

-------

The symbols and statement labels for topology were changed
in order to conform more closely to the terminology in Munkres, who
calls a member of our (old) Open a "topology" and calls a member of our
(old) Top a "topological space".

  Old symbol      New symbol
  ----------      ----------
  Top             TopSp
  Open            Top

  Old label       New label
  ---------       ---------
  ctop            ctps
  cope            ctop
  df-top          df-topsp
  df-open         df-top
  dfopen2         dftop2
  optop           eltopsp
  elopen1         istop
  elopen2         uniopnt
  op-empty        0opnt
  empty-op        sn0top
  op-indis        indistop

-------

If J is a topology on a set X, then X is equal to the union of J.  For
this reason, the first member of a topological space <X,J> is redundant.
I am doubtful that the topological space definition will offer any real
benefit and am considering deleting it.  If anyone knows of a good
reason to keep it, let me know.


(12-Jul-2006) I added definitions for topology (df-open and df-top),
and added some theorems that Stefan Allan proved back in Feb. and
March.  Note that "e. Open" and "e. Top" are equivalent ways of saying
something is a topology, which will be shown by the (in progress)
theorem "( <. U. A , A >. e. Top <-> A e. Open )", and "e. Open" is
often simpler.


(7-Jul-2006) Over 100 *OLD's were removed from the database,
and 83 remain, 27 of which are in the Hilbert space section.  After
subtracting the *OLD's, there are 6053 theorems in the non-Hilbert-space
part and 1181 for Hilbert space, a total of 7243.

This is the first time I have become aware that the Metamath Proof
Explorer has officially passed the 6000 theorem "milestone", which
happened 53 (green) theorems ago.  The 6000th theorem was mt4d, added on
18-Jun-2006.


(6-Jul-2006) With the updated projlem31, all uses of ~~>OLD have been
eliminated.  Soon I will remove the corresponding *OLD theorems from
the database.

(5-Jul-2006) With ege2le3, we have finally completed the
non-Hilbert-space conversion of ~~>OLD based theorems, so that no
theorem in the non-Hilbert-space section depends on ~~>OLD anymore.  We
can't delete their *OLD theorems yet, because ~~>OLD is still used in a
few places in the Hilbert space section, but that should happen soon.
(If you type "show usage cliOLD/recursive" you will see, before the
Hilbert space section, the *OLDs that will be deleted.  I will delete
them when the Hilbert space stuff is finished being converted to ~~>.)

By the way, we can also now delete all uses of sum1oo ("show usage
csuOLD /recursive"), which I will do soon.


(4-Jul-2006) Currently there are separate derivations of 2 <_ e,
e <_ 3, and 2 <_ e /\ e <_ 3.  Eventually, I'll probably delete the
first two, but for now my immediate goal is to replace the *OLDs.


(1-Jul-2006) The proof of class2seteq was shortened.  Compare the
previous version, class2seteqOLD.


(30-Jun-2006) Continuing with the *OLD cleanup project, the future
ereALT (to replace the existing ereALTOLD) will be an alternate
derivation of ere.  The proof of ereALTOLD specifically focuses on the
number e and has a much simpler overall derivation than ere, which is a
special case of the general exponential function derivation.  The lemmas
for ereALTOLD are mostly reused to derive the bounds on e (ege2OLD,
ele3OLD, ege2le3OLD).  Since ereALTOLD ends up being a natural byproduct
of those theorems, I have so far kept it even though it is redundant, in
order to illustrate a simpler alternate way to prove e is real.

By the way, if you are wondering how the mmrecent page can "predict" a
future theorem, the web page generation program simply puts "(future)"
after the comment markup for any label not found in the database (and
also issues a warning to the user running the program).  The mmrecent
page is refreshed with the "write recent" command in the metamath
program.


(21-Jun-2006) The conversion of cvgcmp3ce to cvgcmp3cet is one of our
most complex uses to date of the Weak Deduction Theorem, involving
techniques that convert quantified hypotheses to antecedents.  The
conversion is performed in stages with 2 lemmas.  (Eventually I want to
look at proving the theorem form directly, with the hope of reducing the
overall proof size.  But for now my main goal is to replace the *OLDs.)


(20-Jun-2006) As mentioned below, most of the recent convergence stuff
like cvgcmp3ce is slowly replacing the *OLDs.  My goal is to be able to
delete a big batch of *OLDs, used to develop the exponential funtion
df-ef, within 2 weeks.  We can't get rid of them until the last piece in
the chain of proofs is completed.


(6-Jun-2006) caucvg will replace caucvgOLD as part of the *OLD
elimination project.  BTW Prof. Wachsmuth doesn't know where this proof
is from; he may have originated it:  "I wrote many of the proofs years
ago and I don't remember a good reference for this particular one"
(email, 6-Jun).  It is a nice proof to formalize because it is more
elementary than most, in particular avoiding lim sups.  (We have
df-limsup defined, but it needs to be developed.  As you can see,
df-limsup is not so trivial.  One of its advantages is that it is
defined - i.e. is an extended real - for all sequences, no matter how
ill-behaved.)


(5-Jun-2006) kbass2t is the 2nd bra-ket associative law mentioned in
the notes of 17-May-2006.


(4-Jun-2006) The description of ax-un was made clearer based on a
suggestion from Mel O'Cat.


(2-Jun-2006) unierr is our first theorem related to qubits and quantum
computing.  In a quantum computer, an algorithm is implemented by
applying a sequence of unitary operations to the computer's qubit
register.  A finite number of gates selected from a fixed, finite set
cannot implement an arbitrary unitary operation exactly, since the set
of unitary operations is continuous.  However, there is a small set of
quantum gates (unitary operations) that is "universal," analogous to the
universal set AND and NOT for classical computers, in the sense that any
unitary operation may be approximated to arbitrary accuracy by a quantum
circuit involving only those gates.  Theorem unierr tells us,
importantly, that the worst-case errors involved with such
approximations are only additive.  This means that small errors won't
"blow up" and destroy the result in the way that, say, a tiny
perturbation can cause completely unpredictable behavior in weather
prediction (the "butterfly effect").


(1-Jun-2006) Someone complained about not being able to understand infpn
(now called infpn2), so I decided to make the "official" infpn use only
elementary notation.


(27-May-2006) The label of the ubiquitous 'exp' (export) was changed to
'ex' to prevent it from matching the math token 'exp' (exponential
function), in anticipation of the 24-Jun Metamath language spec change.
Normally I don't mention label changes here - they're documented at the
top of set.mm - but ex, used 724 times, is the 5th most frequently used
theorem, so this change will almost certainly impact any project using
set.mm as a base.  Although ex is of course not new, I re-dated it to
show up in today's "Most Recent Proofs."


(25-May-2006) I think csbnest1g is interesting because the first
substitution is able to "break through" into the inside of the second
one in spite of the "clashing x's".  Compare csbnestg, where x and y
must be distinct.  I found it a little tricky to prove, and I wasn't
even sure if it was true at first.


(18-May-2006) kbasst proves one of the associative laws mentioned
yesterday:

  Dirac:  ( |A> <B| ) |C> = |A> ( <B| |C> )
  Metamath: ( ( A ketbra B ) ` C ) = ( ( ( bra ` B ) ` C ) .s A )


(17-May-2006)   Dirac bra-ket notation deciphered

Most quantum physics textbooks give a rather unsatisfactory, if not
misleading, description of the Dirac bra-ket notation.  Many books will
just say that <A|B> is defined as the inner product of A an B, or even
say that it _is_ the inner product, then go off and give mechanical
rules for formally manipulating its "components" <A| and |B>.  For
physicists, "formally" means "mechanically but without rigorous
justification."

If the dimensions are finite, there is no problem.  A finite-dimensional
Hilbert space is essentially linear algebra, and it is possible to prove
that any vector and linear operator can be represented by an n-tuple
(column vector) and matrix respectively.  In finite dimensions, we just
define |B> to be a column vector and <A| its conjugate transpose, a row
vector.  Viewed this way, the various combinations such as <A|B> (the
inner product) and |A><B| (a matrix) make sense in finite dimensions.

But what is the "transpose" of a vector in infinite-dimensional Hilbert
space?  To answer this, some of the more mathematically "rigorous" books
say that |B> is a member of Hilbert space (a vector) and call <A| a
member of a "dual space" of functionals, which defined such that the
value of functional <A| evaluated at vector |B> equals the inner product
of A and B. While this solves some of the problems, mysteries remain,
such as, what is the "outer product" |A><B|?  They don't say (it is very
rare to find a QM book with "outer product" in the index), and they
evade the problem by implicitly assuming an (unproven) associative law
that allows them to manipulate their way out of having to explain it.
But the in-between stages of manipulation can contain undefined objects,
and while the mechanical rules "work," there isn't an obvious way to
formalize them.  In particular, the associative law cannot be proved
from Hilbert space axioms from the partial definitions given in most
books.

Maybe it's just the way my brain works, but I find it difficult to
become comfortable with a concept that isn't precisely defined, even if
it "works."  An advantage (as well as a frustration) of Metamath is
that it forces you to resolve any such issues if you want to make
progress.

Fortunately, I found a book by Eduard Prugovecki (pronounced
Proo-go-vetch-kee), _Quantum Mechanics in Hilbert Space_, that (on
p. 376) presents a defining equation for |A><B|, which you can see as
today's theorem kbvalvalt, from which we can deduce a direct definition
(df-kb) that works in both finite- and infinite-dimensional Hilbert
space.  With this final clue, I was able to map precise set-theoretical
expressions uniquely to and from all possible Dirac bra and ket
combinations.  The mapping is somewhat complicated, but it is complete
and well-defined.  In order to accomplish this, I introduced two new
definitions.  The "bra" function takes in a vector and outputs a
functional.  The "ketbra" operation takes two vectors and outputs an
operator.  Their definitions are given by df-bra and df-kb.

  Added 18-May-06:  I noticed that the Wikipedia bra-ket article, added
  last year, also defines outer product (in the same way as Prugovecki).

Note that a "functional" is any function from H~ (Hilbert space) to CC
(complex numbers), and an "operator" is any function from H~ to H~.

The rule for combining bras and kets is that a bra may be placed after a
ket and vice-versa, but two bras and two kets may not be juxtaposed.  In
other words, bras and kets must alternate.  Juxtaposition can be thought
of roughly, but not exactly, as a kind of "product."  Juxtaposition is
associative:

  ( |A> <B| ) |C> = |A> ( <B| |C> )
  ( <A| |B> ) <C| = <A| ( |B> <C| )

(Added 24-May-2006) There is a technicality in our development.
Mathematicians, and set.mm, define inner product such that
( C x. ( A .i B ) ) = ( ( C .s A ) .i B ).  Physicists define it such
that ( C x. ( A .i B ) ) = ( A .i ( C .s B ) ) where ".s" is the scalar
product of a number and a vector and ".i" is the inner product of two
vectors.  See the description for ax-his3.  I used to think this was
arbitrary, with physicists having a slightly less natural definition for
no good reason.  (I have never seen a book explain why.)  It turns out
that the physicist definition is necessary for the bra-ket notation to
work!  Specifically, the second associative law above fails with the
mathematicians' definition.  Since set.mm adopts the mathematicians'
definition in order to be compatible with math books, we therefore will
consider the bra-ket <A|B> to be defined as ( B .i A ).  So now we have
the "best of both worlds" and can choose either <A|B> (which physicists
consider synonymous with inner product) or (A .i B) = <B|A>, to match
whatever text we're working with.

There are actually 4 kinds of objects that result from different bra and
ket juxtapositions:  complex numbers, vectors, functionals, and operators.
This is why juxtaposition is not "exactly" a product, because its
meaning depends on the kind of objects that the things being juxtaposed
represent.  The starting operations on vectors are as follows:

                                                             Finite dim.
   Operation       Notation  Metamath        Value           analogy

   ket             |A>       A               vector          column vector
   bra             <A|       ( bra ` A )     functional      row vector
   inner product   <A|B>     ( B .i A )      complex number  complex number
   outer product   |A><B|    ( A ketbra B )  operator        matrix

The inner product <A|B> can also be expressed as ( ( bra ` A ) ` B )
- as today's theorem bravalvalt shows - and this will be needed to use
the table below (in line 5).  (Lines 3 and 4 in the above table are
redundant, since they are special cases of lines 5 and 4 below; line 4
above is computed ( A ketbra ( `' bra ` ( bra ` B ) ) ) = ( A ketbra B ).)

We will represent the four kinds of possible results in the "Value"
column above as v, f, c, and o respectively.  After accounting for the
restrictions on juxtaposing bras and kets (e.g., we can never have an
inner product followed by a ket), exactly the following cases can occur
when two Dirac subexpressions T and U are juxtaposed to produce a new
Dirac expression TU:

  T  U  TU  Metamath operation           Description

  c  c   c  ( T x. U )                   Complex number multiplication
  c  f   f  ( T .fn U )                  Scalar product with a functional
  v  c   v  ( U .s T )                   Scalar product (note T & U swap)
  v  f*  o  ( T ketbra ( `' bra ` U ) )  Outer product (with converse bra)
  f  v   c  ( T ` U )                    Inner product (bra value)
  f  o   f  ( T o. U )                   Functional composed with operator
  o  v   v  ( T ` U )                    Value of an operator
  o  o   o  ( T o. U )                   Composition of two operators

  *Note:  In line 4, U must be a continuous linear functional (which will
  happen automatically if U results from a string of kets and bras).
  This is needed by the Riesz theorem riesz2t, which allows the
  inverse bra to work.  The other lines have no restriction.

  See df-hfmul for ".fn", df-co for "o.", and df-cnv for "`'".

  Line 5 can be stated equivalently:

    f* v   c  ( U .i ( `' bra ` T ) )      Inner product (with converse bra)

So, the "operation" of juxtaposition of two Dirac subexpressions can
actually be any one of 8 different operations!  This is why we can't
easily express the Dirac notation directly in Metamath, since a class
symbol for an operation is supposed to represent only one object.

Supplementary note:  Physics textbooks will often have equations with an
operator sandwiched between a bra and a ket.  Its juxtaposition with a
bra or ket also now becomes easy to formalize:  match an entry from the
table above where the operator corresponds to an "o" input.

As an example of the use of the above table, consider the associative
laws above and their set-theoretical (Metamath) translations, which
we will eventually prove as theorems in the database.

  Dirac:  ( |A> <B| ) |C> = |A> ( <B| |C> )
  Metamath: ( ( A ketbra B ) ` C ) = ( ( ( bra ` B ) ` C ) .s A )

  Dirac:  ( <A| |B> ) <C| = <A| ( |B> <C| )
  Metamath:  ( ( ( bra ` A ) ` B ) .fn ( bra ` C ) ) =
                        ( ( bra ` A ) o. ( B ketbra C ) )

Note that ( A ketbra B ) above is really ( A ketbra ( `' bra ` ( bra ` B ) ) )
- see table line 4 - but we will adopt the convention of canceling
converse-bra bra since ( `' bra ` ( bra ` B ) ) = B.  In some cases
we can't cancel:

  Dirac:  ( | A >. <. B | ) ( | C >. <. D | ) =
          | A >. ( <. B | ( | C >. <. D | ) )

  Metamath:  ( ( A ketbra B ) o. ( C ketbra D ) ) =
             ( A ketbra ( `' bra ` ( ( bra ` B ) o. ( C ketbra D ) ) ) ) )

There you have it, a complete formalization of Dirac notation in
infinite dimensional Hilbert space!  I've never seen this published
before.

For an intuitive feel for the table above, it can be useful to compare
the finite dimensional case using vectors and matrices.  Suppose A and
B are column vectors of complex numbers

     [a_1]      [b_1]
     [a_2]      [b_2]

Then |B> is the same as B, and <A| is the row vector [a_1* a_2*] (where
* means complex conjugate).

Then all the 8 Dirac operations can be justified with vector and matrix
multiplications.  For example, <A|B> becomes the inner product
a_1* x. b_1 + a_2* x. b_2, and |B><A| becomes the 2x2 matrix

     [b_1 x. a_1*   b_1 x. a_2*]
     [b_2 x. a_1*   b_2 x. a_2*]

(It should be mentioned that Dirac notation can also be rigorously
modeled by an algebra known as "rigged Hilbert space," which can be
useful for certain theoretical purposes.  However, rigged Hilbert space
is rather abstract and somewhat removed from the Hilbert space we are
working with.)


(11-May-06) The Description for today's sumeqfv
http://us2.metamath.org:8888/mpegif/sumeqfv.html mentions that A
represents A(k) for those used to the standard way is would be written
in a textbook, meaning that the class substituted for A would normally
have a free variable k in it.  How do we know that A(k) is intended?  It
can be inferred from the fact that A and k do not appear together in a
distinct variable group, i.e. there is no $d A k constraint.

In principle, all theorems could be converted to the A(k) textbook
notation above, and explicit distinct variable groups could be
eliminated, if we make the following assumptions:

1. Implicitly assume all set variables are distinct (like textbooks do).

2. Implicitly assume that a set variable does _not_ occur in an
expression represented by a wff or class variable unless it is present
in the variable's argument list.  E.g., j may _not_ occur in a class
expression substituted for A(k); y _may_ occur (although it doesn't have
to) in a wff expression substituted for ph(x,y,z); etc.  This is also
what textbooks usually assume.

With the above assumptions, we could define, for most theorems (with
an exception explained below), an unambiguous mapping from Metamath's
notation (with explicit $d's and implicit free-variable arguments) to
textbook notation (with implicit $d's and explicit free-variable
arguments) and vice-versa.  Possibly a future display method could do
such a translation automatically, so that that notation becomes more
familiar to mathematically experienced readers.

So why don't we just adopt the textbook-style notation as the underlying
standard that Metamath is based on?  The answer is that the proof
checker would be much more complicated.  Also, see the 2nd paragraph on
http://us2.metamath.org:8888/mpegif/df-sb.html for a problem related to
using this notation to represent substitution, although this could be
avoided (but with associated algorithmic complexity) if we were strict
about assumptions (1) and (2) above.

Of course, a more complex proof checker is no big deal for a computer,
once the program is written.  In fact most proof checkers other than
Metamath do use the explicit-free-variable approach.  So why doesn't
Metamath just use a more complex algorithm?  First, the simpler the
algorithm, the more confidence you can have in its robustness.  But more
importantly, implicit in a complex algorithm is the associated
difficulty in learning how the algorithm works.  I believe that it is
important to understand how the algorithm works if you "really" want to
understand how each proof step was arrived at and not just to accept it
on faith.  In beginning logic courses, the complex rules for free
variables and proper substitution take a significant effort to learn,
whereas Metamath's substitution rule can presumably be learned in a few
minutes (although I have no data on this).  For me, it was a
philosophical goal to make the math as transparent as possible by using
the simplest possible algorithm, and the $d method accomplished that (to
my mind).  Or even better, in principle (although awkward in practice),
the simplest algorithm would use only axioms that avoid $d's entirely:
http://us2.metamath.org:8888/mpegif/mmzfcnd.html

A problem with the explicit-free-variable approach is that it cannot
represent set variables that don't have to be distinct, such as in
x = y -> y = x and A. x A. y ph <-> A. y A. x ph.  To accomodate this,
we could have a notation representing the opposite of a $d that says two
variables are not necessarily distinct.  Alternately, we could adopt the
approach of restating the axiom system so that set variables are always
distinct, as described on
http://planetx.cc.vt.edu/AsteroidMeta//mmj2Feedback (search for "Here is
an idea").  However, in set theory and beyond, situations where set
variables are not required to be distinct are not very common.


(10-May-06) A reader comments at http://www.jaredwoodard.com/blog/?p=5
that he wishes I'd spend less time on Hilbert space and more on cleaning
up *OLDs.

The cleaning up of *OLDs has actually been happening "behind the scenes"
even though people may not notice it.  Almost 200 *OLDs have been
eliminated since January (there were 380 then; now there are 185).
Yesterday's geoser and expcnv will eliminate their corresponding *OLDs,
for example.  Mel O'Cat is also working on a list of 27 of the *OLDs.

I realize hardly anyone cares about the Hilbert space stuff, and regular
visitors are probably bored to tears seeing the dreary purple theorems
day after day.  :)  (I do try not to go too long without a pretty green
one now and then.)  My long term goal is to build a foundation that will
let me explore rigorously some new ideas I have for Hilbert lattice
equations that may lead to writing a new paper.  I also want to build up
a foundation for theorems related to quantum computing.  In a few days
hopefully we will have a theorem related to error growth in qubits
(quantum gates).


(9-May-06) Compare geoser to the old one, geoserOLD, that it replaces.
Wikipedia entry:  http://en.wikipedia.org/wiki/Geometric_series


(5-May-06) The Riesz representation theorem is used to justify the
existence and uniqueness of the adjoint of an operator.  In particular,
the rigorous justification of Dirac bra-ket notation in quantum
mechanics is dependent on this theorem.  See also Wikipedia:
http://en.wikipedia.org/wiki/Riesz_representation_theorem


(13-Apr-06) One thing to watch out for in the literature is how the
author defines "operator".  I put some notes at
http://us2.metamath.org:8888/mpegif/df-lnop.html on the various
definitions:  for some they are arbitrary mappings from H to H, for
others they are linear, for still others they are linear and bounded.
In set.mm, "operator" means an arbitrary mapping.


Today's goal is:  a linear operator is continuous iff it is bounded.
This will be called "lncnbd" when it is completed later today. lnopcon
provides the basic proof of this:  it is not a trivial proof, 220 steps
long, and to me it is non-intuitive.  Many authors forget about the case
of the trivial Hilbert space, where sometimes a result holds and other
times not.  lnopcon does hold, but we have to prove the trivial case
separately, and in step 219 we combine the nontrivial case of step 194
with trivial case of step 218.


(12-Apr-06) The astute observer may have noticed that the dates on
the "Recent Additions to the Metamath Proof Explorer" now have 4-digit
years, e.g. 12-Apr-2006 instead of 12-Apr-06.  Version 0.07.15 of
the metamath program implements 4-digit date stamps, and set.mm has
been updated with 4-digit years.  The program still recognizes 2-digit
years (for the 'write recent' command) but assumes they fall between
1993 and 2092.


(10-Apr-06) The reason the xrub proof is long is that it involves 9
cases:  3 cases for B (real, -oo, and +oo), and for each B, 3 cases for
x. (We handle some of them simultaneously in the proof.)  This theorem
means we only have to "scan" over the reals, rather than all of the
extended reals, in order to assert that B is an upper bound for set A.
This is true even if A contains non-reals or if B is non-real (+oo
or -oo).

When we quantify over all extended reals, often we have to consider the
3 cases of real, -oo, +oo separately.  The advantage of this theorem is
that we don't have to handle the last two cases anymore, so some proofs
will become significantly shorter as a result.


(6-Apr-06) The proof of unictb is very different from Enderton's, which
I found somewhat awkward to formalize.  Instead, it is effectively a
special case of Takeuti/Zaring's much more general uniimadom.

It is also interesting how simple it is to go from the indexed union to
the regular union version of a theorem, whereas it can be rather
difficult in the other direction.  For example, iunctb to unictb is
trivial through the use of uniiun.  But for the finite version of this
theorem, compare the difficulty of going from the regular union version,
unifi to iunfi, requiring the not-so-trivial fodomfi, which was
proved for this purpose.

The conversion of unifi to iunfi involved substituting z for x and
{ y | E. x e. A y = B } for A in unifi, using dfiun2 on the consequent,
and doing stuff to get the antecedents right.  The "doing stuff"
ends up being not so simple.

Perhaps if I had to do it over, it might have been simpler to prove
iunfi first, then trivially obtain unifi via uniiun, although I'm not
really sure.

Both iunctb and iunfi are intended ultimately to be used by a Metamath
development of topology, which Stefan Allan has started to look at.


(1-Apr-06) Today's avril1 http://us2.metamath.org:8888/mpegif/avril1.html
is a repeat of last year's, except for a small change in the
description.  But I bring it up again in order to reply to last year's
skeptics.

Unlike what some people have thought, there is nothing fake about this
theorem or its proof!  Yes, it does resemble an April Fool's prank, but
the mathematics behind it are perfectly rigorous and sound, as you can
verify for yourself if you wish.  It is very much a valid theorem of ZFC
set theory, even if some might debate its relative importance in the
overall scheme of things.  The only thing fake is that Prof. Lirpa uses a
pseudonym, since he or she wishes to remain anonymous.

Tarski really did prove that x=x in his 1965 paper.  While it is
possible he wasn't the first to do so, he did not attribute the theorem
to anyone else.

The theorem

  -. ( A P~ RR ( i ` 1 ) /\ F (/) ( 0 x. 1 ) )

importantly tells us we cannot prove, for example,

  ( A P~ RR ( i ` 1 ) /\ F (/) ( 0 x. 1 ) )

if ZFC is consistent.  If we utter the latter statement, that will
indeed be a hilarious joke (assuming ZFC is consistent) for anyone who
enjoys irony and contradiction!  But anyone who could prove the latter
statement would achieve instant notoriety by upsetting the very
foundation that essentially all of mathematics is built on, causing it
to collapse like a house of cards, into a pile of (Cantor's) dust that
would blow away in the wind.  That assumes, of course, that the paradox
is not hushed by the established mathematical community, whose very
livelihoods would be at stake.  In that case, the discoverer might
achieve wealth instead of fame.

So, in effect the theorem, being preceded by the "not" sign, really
tells us:  "I am _not_ an April Fool's joke."  Thus we are reminded of
the Liar Paradox, "this sentence is not true," but with an important
difference:  paradoxically, avril1 is not a paradox.

For those whose Latin is rusty, "quidquid germanus dictum sit, altum
viditur" means "anything in German sounds profound."  Just as logicians
have done with Latin ("modus ponens" and so on), set theorists have
chosen German as their primary obfuscating language.  For example, set
theory texts lend great importance and mystery to the otherwise trivial
subset axiom by calling it "Aussonderung."  This helps keep the number
of set theorists at a comfortable level by scaring away all but a few
newcomers.

To derive avril1, we have used an interdisciplinary approach that
combines concepts that are ordinarily considered to be unrelated.  We
have also used various definitions outside of their normal domains.
This is called "thinking outside of the box."  For example, the
imaginary constant i is certainly not a function.  But the definition of
a function value, df-fv, allows us to substitute any legal class
expression for its class variable F, and i is a legal class expression.
Therefore ( i ` 1 ) is also a legal class expression, and in fact it can
be shown to be equal the empty set, which is the value of "meaningless"
instances of df-fv, as shown for example by theorem ndmfv.

http://us2.metamath.org:8888/mpegif/df-fv.html
http://us2.metamath.org:8888/mpegif/ndmfv.html

Now that the technique has been revealed, I hope that next year someone
else will make a contribution.  You have a year to work on it.


(28-Mar-06) sspr eliminates the hypotheses of the older version, which
has been renamed to ssprOLD.


(27-Mar-06) As of today's version of set.mm, 183 out of the 315 theorems
with names ending "OLD" were removed, so there are only 132 *OLDs left.
This has made set.mm about 300KB smaller.  (The 132 remaining can't just
be deleted, since they currently are referenced by other proofs, which
will have to be revised to eliminate their references.  Mel O'Cat has
started working on some of them.)


(20-Mar-06) Stefan has done the "impossible," which is find an even
shorter proof of id.  (See the note of 18-Oct-05 below.)  His new proof
strictly meets the criteria I use for accepting shorter proofs
(described at the top of the set.mm file).  He writes, "Too bad you
don't get a special prize for shortening this one!"  I agree; any
suggestions?

About a1d, he writes, "[a1d] is not a shorter proof in compressed
format, and is in fact the same size as the old one.  However it has
fewer steps if expanded out into axioms, so you might want to include it
in set.mm anyway."


(24-Feb-06) Stefan's sylcom proof has 1 fewer character in set.mm than
the previous, and 9 fewer characters in its HTML file.  I think we may
be approaching the theoretical limit.  :)


(22-Feb-06) The proof of efcj uses some obsolete theorems with the old
convergence ~~>OLD, but I don't have the updated ones ready yet and just
wanted to get efcj out of the way since we will need it for more
trignometry.  Eventually the proof of efcj will be updated.  Note that
"obsolete" doesn't mean "unsound"; the proof is perfectly rigorous.  The
purpose of the new notation is to make proofs more efficient (shorter)
once everything is updated with it.

(17-Feb-06) efadd was completed a little sooner than I thought.  Here
are some statistics:  the set.mm proof (efadd + 28 lemmas) takes 47KB
(out of 4.5MB for set.mm).  The HTML pages take 4.7MB (out of 372MB
total for mpegif).

(13-Feb-06) Over the next couple of weeks, we will be proving what has
turned out to be a difficult theorem - the sum of exponents law for the
exponential function with complex arguments, i.e. e^(a+b)=e^a.e^b.  Even
though textbook proofs can seem relatively short, the ones I've seen
gloss over many of the tedious details.  After several false starts I
came up with a proof using explicit partial sums of product series and
explicit comparisons for the factorial growth (we will use the recent
fsum0diag and faclbnd4 for this).  The whole proof will have around
30 lemmas.

(12-Feb-06) nonbool demonstrates that the Hilbert lattice is
non-Boolean.  This proves that quantum logic is not classical.  Of
course this is well known, but I've only seen it stated without proof,
so I came up with a formal demonstration.  It seems the dimension
must be at least 2 to demonstrate non-Boolean behavior.

Note that we have already shown that it is orthomodular (in pjoml4),
but Boolean is a special case of orthomodular, so that in itself doesn't
demonstrate that quantum logic is not classical.

(11-Feb-06) Even though the climmul proof is long, I'm not unhappy about
it, since Gleason dedicates over 2 pages to the proof (although some of
it is an informal discussion of how one goes about coming up with such a
proof).

While our proof roughly follows Gleason, our trick of constructing a new
positive number less than both A and 1, given a positive number A, is
not in Gleason - he uses the infimum of A and 1 (bottom of page 170),
which would be more awkward (for us at least) to deal with.  This trick
is proved by recrecltt and is used in climmullem5.

(9-Feb-06) I found a slightly shorter equivalent for ax-groth expanded to
primitives.  The idea was to use fun11 at step 42, so that the old steps
42-60 become 42-48.  But the result was a little disappointing.  I had
higher hopes for the idea but it only ended up removing one binary
connective.  At least the proof is 59 instead of 71 steps.  (The old one
has been kept temporarily as grothprimOLD.)  Probably the biggest problem
is the repeated use of grothlem (4 times) to expand binary relations.
I wonder if there is a shorter way to effectively express this concept.

(8-Feb-06) dummylink was added for a project to interface O'Cat's mmj2
Proof Assistant GUI with the metamath program's Proof Assistant, but
I've discovered that it can be quite handy on its own as suggested by
its description.  For more background see "Combining PA GUI and CLI - an
interim solution?" at the bottom of web page
http://planetx.cc.vt.edu/AsteroidMeta/mmj2ProofAssistantFeedback

(Downloaders - the Metamath download containing this proof will be in
tomorrow's download.  In general, the Most Recent Proofs usually take
about a day to propagate to the downloads.)

(4-Feb-06) More shorter proofs by O'Cat - pm2.43d, pm2.43a.

rcla4cv ended up shortening 26 proofs by combining rcla4v and com12.
The result was a net reduction in the database size, even after
accounting for the new space taken by rcla4cv.

(3-Feb-06) Mel O'Cat found shorter proofs for sylcom, syl5d, and syl6d
while having fun with his new toy, the Proof Assistant GUI.

Note:  the new proofs of of syl5d and syl6d have the same number of
logical steps, but proofs are shorter if we include the unseen
wff-building steps.  Out of curiosity I restored the original syl5d
proof, since it had already been shortened by Josh Purinton, and called
it syl5OLDOLD.  Here are the complete proofs for the syl5d versions:

syl5d:  14 steps

  wph wps wta wch wth wph wta wch wi wps syl5d.2 a1d syl5d.1 syldd $.

syl5dOLD:  16 steps

  wph wps wch wth wi wta wth wi syl5d.1 wph wta wch wth syl5d.2 imim1d
  syld $.

syl5dOLDOLD:  19 steps

  wph wta wps wth wph wta wch wps wth wi syl5d.2 wph wps wch wth syl5d.1
  com23 syld com23 $.


(30-Jan-06) Today we start a brand new proof of the binomial theorem
that will be much shorter than the old one.  It should also be much more
readable.  This is what the new one will look like (A e. CC, B e. CC):

( N e. NN0 -> ( ( A + B ) ^ N ) = sum_ k e. ( 0 ... N )
         ( ( N C. k ) x. ( ( A ^ ( N - k ) ) x. ( B ^ k ) ) ) )

Compare to the old, binomOLD:

( ( N e. NN0 /\ A. k e. ( 0 ... N ) ( F ` k ) =
               ( ( N C. k ) x. ( ( A ^ k ) x. ( B ^ ( N - k ) ) ) ) ) ->
                   ( ( A + B ) ^ N ) = ( <. 0 , N >. sumOLD F ) )

(24-Jan-06) (Compare note of 22-Oct-05.)  Per the request of Mel O'Cat,
I eliminated all connective overloading in set.mm by making weq, wel,
and wsb "theorems" so that he can use set.mm with his GUI Proof
Assistant.  This involved moving set theory's wceq, wcel, and wsbc
up into the predicate calculus section, which is somewhat confusing,
so I added extensive commenting to explain it hopefully.

Note that the web page "proofs" of weq, wel, and wsb have only one step:
this is because they are syntax proofs, and all syntax building steps
are suppressed by the web-page generation algorithm, which doesn't
distinguish weq, etc. from "real" theorems.  I'm not yet sure if it's
worth changing the algorithm for this special case.  To see the actual
steps, in the Metamath program type "show proof weq /all".

(20-Jan-06) supxrcl shows the usefulness of the extended reals:  the
supremum of any subset always exists.  Compare the non-extended real
version suprcl, which has a complicated antecedent that must be
satisfied.

(19-Jan-06) A new set theory axiom, ax-groth, was added to the database.
This axiom is used by Mizar http://mizar.org to do category theory (that
ZFC alone cannot do), and I think it is appropriate to add it to set.mm.
One of the negative aspects of this axiom (aesthetically speaking) is
that it is "non-elementary" and very ugly when expanded to primitives,
unlike the ZFC axioms.  I worked out grothprim because I was curious to
see what it actually looks like.  I don't think grothprim will actually
be used for anything since it is impractical; instead, ax-groth would be
the starting point.  However, grothprim can provide a benchmark for
anyone seeking a shorter version.  There may be a theoretical reason why
it can't be as short as say ax-ac, but I don't think anyone knows what
the shortest possible equivalent is.

mmset.html has also been updated to include ax-groth below the ZFC
axioms.

I wrote to Jeff Hankins:

  I added ax-groth partly in response to your email on Mycielski's ST set
  theory,* although it's been on my backburner for a while.  In my mind,
  ax-groth "completes" set theory for all practical purposes.  (The Mizar
  people, who use this axiom, also think so.)  Unlike the controversial
  assertions of ST, ax-groth is relatively mild and uncontroversial - I
  don't know of any debate over it, unlike the debate on the Continuum
  Hypothesis.  I am pretty sure that Mycielski's Axiom SC implies ax-groth
  from his comments, although I haven't worked out a proof.  So
  ZFC+ax-groth is most likely a subset of ST.

* http://www.ams.org/notices/200602/fea-mycielski.pdf - free AMS
sign-up required to view article

(12-Jan-06) The exponential function definition df-ef is new.
Yesterday's version of df-ef was reproved as theorem dfefOLD that
will eventually be deleted after the old infinite summation notation is
phased out.

Compare the new exponential function value formula, efvalt, with the old
one, efvaltOLD.  Don't you agree that it is much easier to read?  This
kind of thing makes me believe that the effort to introduce the new
summation notation was worthwhile.  :)  In addition, will have a much
nicer version of the binomial theorem (whose old version has already
been renamed to binomOLD), with a much shorter proof - stay tuned!

(11-Jan-06) isumvalOLDnew links the old and new definitions of infinite
sum, allowing us to temporarily reuse theorems in the old notation until
they are phased out.  See comments below of 1-Nov-05, 2-Nov-05,
20-Dec-05, and 21-Dec-05 regarding the new finite/infinite sum notation
df-sum.

The present definition of the exponential function, df-ef, makes use of
the obsolete infinite sum notation. dfefOLDnew will replace df-ef in the
next few days and become its new official definition.  The old df-ef
will become a (temporary) theorem that will be used to support the old
infinite sum notation until it is phased out.

gch-kn was updated with new hyperlinks.

(10-Jan-06) Regarding the 9-Jan-06 item in "Also new", the primary
reason I added the "/except" switch to "minimize_with" was to exclude
3syl.  While 3syl may shorten the uncompressed normal proof, it often
makes compressed proofs grow longer.  This happens when the intermediate
result of two chained syl's is used more than once.  When the
intermediate result disappears due to 3syl, two formerly common
subproofs have to be repeated separately in the compressed proof - part
of the compression is achieved by not repeating common subproofs.  So,
typically I exclude 3syl then minimize with it separately to see if the
compressed proof shortens or lengthens.  Maybe I'll add an option to
also check the compressed proof length instead of or in addition to the
normal proof length, but the "/exclude" was easier to program, and
curiously 3syl is the only problematic theorem I'm aware of.

(9-Jan-06) climOLDnew is a temporary theorem that links the old and new
limit relations, ~~>OLD and ~~>.  This will let us "jump ahead" and work
on exponentiation, etc. with the new notation before cleaning up all the
~~>OLD stuff (which I will still clean up eventually).  The linkage is
needed to avoid any gaps in the released set.mm.  (The metamath command
"verify proof *" should always pass for the daily releases of set.mm,
ensuring absolute correctness of its contents - even the stuff that's
obsolete.)

The main difference between ~~>OLD and ~~> is that ~~>OLD has the rigid
constraint that the sequence F be a function from NN to CC, whereas ~~>
allows F to be any set with lots of irrelevant garbage in it as long as
it eventually has function values in CC beyond some arbitrary point.
This can make ~~> much more flexible and easier to use.

The uppercase "OLD" in climOLDnew means the theorem will go away; for my
cleanup I will be phasing out and deleting all theorems matching *OLD*.
Currently there are 380 *OLD* theorems due to be phased out.  They can
be enumerated by counting the lines of output of the metamath command
"show label *OLD*/linear".

(6-Jan-06) syl*el* are all possible combinations of syl5,syl6 analogs
for membership and equality.  I added them to shorten many proofs, since
these patterns occur frequently.  (Since 1999 I've added the syl*br*
versions of these for binary relations and found them useful, so I
decided to add the syl*el* versions.)  There is a curious asymmetry in
which ones ended up being useful:  syl5eqel got used over 30 times,
whereas syl5eleq isn't used at all so far.  I don't know if this is
because I wrote the original proofs with certain patterns subconsciously
repeated, or if there is something more fundamental.

(3-Jan-06) r19.21aiva adds 319 bytes to the database, but it reduces the
size of about 50 (compressed) proofs by 765 bytes total, for a net
reduction in database size of 466 bytes.

(21-Dec-05) All theorems that involved df-fsum have been updated to use
the dual-purpose (finite and infinite) df-sum instead.  So, we now have:

       Definition               Token                Symbol
  Yesterday   Today       Yesterday Today     Yesterday   Today
  df-sum      df-sum      sum_NEW   sum_      \Sigma_NEW  \Sigma
  df-fsum     df-fsum     sum_      sum_OLD   \Sigma      \Sigma_OLD
  df-fsumOLD  df-fsumOLD  sumOLD    sumOLD    \Sigma_OLD  \Sigma_OLDOLD

The names with "OLD" are now kind of oddly inconsistent, but everything
with "OLD" in it (whether label or token) will eventually be deleted so
it doesn't really matter.

(20-Dec-05) The new finite sum stuff looks like it will be very useful,
and we will need an infinite sum version to replace the current df-isum.
Rather than repeat the whole development with new equality, bound
variable, etc. utility theorems, I decided to combine the two
definitions.  The new combined definition is called df-sum, which is
basically the union of two definitions.  The index range (finite or
infinite) determines whether the sum is finite or infinite.  See the
comments in df-sum.  We need about half a dozen utility theorems.  Then,
after changing the "sigmaNEW" to "sigma", we can "plug in" the new
definition and re-use the theorems we have already developed for finite
sums without further modification.

fzneuzt is the basic theorem that lets us distinguish the finite
half vs. the infinite half of df-sum.

(14-Dec-05) fsum1sNEW (to be renamed fsum1s) exploits class2set to
eliminate the hypothesis of fsum1slem, so that we require only existence
of A(M) as a member of some arbitrary class B, rather than requiring
that it be a complex number (as yesterday's fsum1s requires).  This will
shorten future proofs by allowing us to apply fsum1sNEW directly when A
is a real, rational, etc.  I had almost forgotten about class2set, which
I think is a neat trick.  Yesterday's fsum1s will be renamed to
fsum1sOLD and eventually deleted.

I'm not sure if fsum1s2 will be useful, but it lets us show off an
application of the interesting fz1sbct.

(13-Dec-05) fsum1slem shows an example of a use for the new
substitution-for-a-class notation.  Compare it to the implicit
substitition version fsum1.

fsum1s turns the hypothesis A e. V of fsum1slem into an antecedent.
Since A is quantified, we have to work a little harder than usual to
accomplish this.

(4-Dec-05) See http://planetx.cc.vt.edu/AsteroidMeta//metamathMathQuestions
for comments on equsb3.

(30-Nov-05) csbnestg is the same as csbnestglem except that it has fewer
distinct variable restrictions.  Its proof provides another example of a
way to get rid of them; the key is using a dummy variable that is
eliminated with csbcog.  I think it is a neat theorem and was pleasantly
surprised that so few distinct variable restrictions were needed.  The
antecedents just say that A and B are sets and are easily eliminated in
most uses.  By having antecedents instead of A e. V, B e. V hypotheses,
we can make more general use of the theorem when A and B sethood is
conditioned on something else; hence the "g" after "csbnestg".

(23-Nov-05) In all versions of set.mm from 18-Nov-05 to 22-Nov-05 inclusive,
the line

  htmldef "QQ" as "<IMG SRC='bbieq.gif' WIDTH=13 HEIGHT=19 ALT='QQ' ALIGN=TOP>";

should be

  htmldef "QQ" as "<IMG SRC='bbq.gif' WIDTH=13 HEIGHT=19 ALT='QQ' ALIGN=TOP>";

Thanks to Jeff Hankins for pointing this out.


(18-Nov-05) sbccom is the same as sbccomlem except that it has fewer
distinct variable restrictions.  Its proof shows an example of how to
get rid of them when they are not needed.

-------

I made around 80 changes to the bixxx series names to be
consistent with earlier bixxx -> xxbix changes in prop. calc.  E.g.
biraldv was changed to ralbidv.

  r - restricted
  al - for all
  bi - biconditional
  d - deduction
  v - $d instead of bound-variable hypothesis

Also, bi(r)abxx were changed to (r)abbieqxx e.g. biabi was changed to
abbieqi.

  ab - class abstract (class builder)
  bi - hypothesis is biconditional
  eq - conclusion is equality
  i - inference

As usual, all changes are listed at the top of set.mm, and as instructed
there can be used to create a script to update databases using set.mm as
their base.  As always, better naming suggestions are welcome.

(17-Nov-05) abidhb is a very neat trick, I think!  It will let us do
things that the Weak Deduction Theorem by itself can't handle.  For its
first use, we create a "deduction" form of the bound-variable hypothesis
builder for function values, hbfvd - this is actually a closed form that
allows _all_ hypotheses to be eliminated, since 'ph' is arbitrary and
can be replaced with a conjunct of the hypotheses.  And the only thing
hbfvd needs is the "inference" version hbfv in step 5!  Before I thought
of abidhb, hbfvd was going to require a long chain of hbxxd's (hbimd,
hbabd,...) that would build up to the function value definition.  I was
actually starting to get depressed about the amount of work that would
have been needed.  But as they say, laziness is the mother of invention.
Now, we can just add hbxxd's as needed, starting from the hbxx
"inference" versions!

(15-Nov-05) Note that fsumeq2 requires a $d for A and k, whereas fsumeq1
doesn't.  On the other hand, we have analogously iuneq1 and iuneq2,
neither of which require the bound variable to be distinct!  I spent a
lot of time trying to get rid of it for fsumeq2 by changing the
definition df-fsum, but it always seemed that if I got rid of it in
fsumeq2 it would show up in fsumeq1.  So I don't know whether it is
theoretically possible to get rid of it.  In the current version of the
fsumeq2 proof, the $d is needed to satisfy resopab in steps 9 and 10.

Getting rid of $d A k in fsumeq2 would be advantageous if I add an
"explicit substitution" form of induction like (for ordinals) Raph
Levien's findes, where the hypothesis findes.2 has the substituted
variable free in the expression to be substituted.  So, if anyone can
solve this, let me know!

(14-Nov-05) Today we introduce a new definition, df-csbc, the proper
substitution of a class variable for a set into another class variable.
We use underlined brackets to prevent ambiguity with the wff version,
otherwise [ x / y ] A R B could mean either x e. { y | A R B } for the
df-sbc wff version or <. [ x / y ] A , B >. e. R for the df-csbc class
version.  So instead we use [_ x / y ]_ A for the class version.  One
reason I chose the underline is that it is easy to do in Unicode and
LaTeX, but if you have another idea for the notation let me know.  See
notes of 5-Nov-05 for other notes on the definition.

(13-Nov-05) I decided to make the new finite summation notation df-fsum
official.  The old has been renamed to df-fsumOLD.  I am uncertain about
whether to keep the old (under a different name yet to be determined) or
delete it eventually.  There are 61 theorems using it (21 of which are
the binomial theorem binom) which I hope to eventually re-prove with the
new notation.

(5-Nov-05) Regarding sbabex:  The notation "[ y / x ] ph" means "the
proper substitution of y for x in phi".  We do not have a separate
notation for the class version of this, so until such time (if it
becomes common enough to warrant a special notation), the idiom
"{ z | [ y / x ] z e. A }" means "the proper substitution of y for x in
class variable A".  In other words we turn the class into a wff - the
predicate "is in A" - then do the proper substitution, and finally turn
the result back into a class by collecting all sets with this predicate.
I think that's a neat trick, and it will become the definition if we
introduce a notation for it.  Note that the argument of "[ y / x ]" is
"z e. A", which is a wff.

(2-Nov-05) I have about a dozen theorems in progress with the current
'df-fsum' notation, that I might as well finish before switching to the
new notation.  These will provide reference proofs that will make the
corresponding versions in the new notation easier to prove, but they
will eventually be deleted (assuming I adopt the new notation, whose
definition I'm still fine tuning.)

Not all theorems will be shorter with the new notation, which is one
reason for my indecision.  For example:

Old: (fsumserz)

|- F e. V  =>  |- ( N e. ( ZZ> ` M ) ->
       ( <. M , N >. sum F ) = ( ( <. M , + >. seq F ) ` N ) )

New: (fsumserzNEW)

|- F e. V  =>  |- ( N e. ( ZZ> ` M ) ->
        sumNEW k e. ( M ... N ) ( F ` k ) = ( ( <. M , + >. seq F ) ` N ) )


(1-Nov-05) The proof of the binomial theorem painfully illustrates that
the current notation for summations is very awkward to work with,
particularly with nested summations.

A new definition I'm experimenting with is df-fsumNEW, which, unlike
df-fsum (which is a class constant with no arguments), has a dummy
variable k and two other arguments.  To indicate the sum A^1 + A^2 +...+
A^N, we can write

  sumNEW k e. ( 1 ... N ) ( A ^ k )

instead of the present

  ( <. 1 , N >. sum { <. k , y >. | ( k e. ZZ /\ y = ( A ^ k ) ) } )

(where usually the class builder is stated as a hypothesis like
F = { <. k , y >. | ( k e. ZZ /\ y = ( A ^ k ) ) } to keep the
web page proof size down).  Nested sums are even more awkward, as
the hypothesis "G =" in the binomial lemmas shows.

With the new notation, the binomial theorem would become:

  ( N e. NN0 -> ( ( A + B ) ^ N ) = sumNEW k e. ( 0 ... N )
          ( ( N C. k ) x. ( ( A ^ k ) x. ( B ^ ( N - k ) ) ) ) )

The price we pay is that 'sumNEW' is not just a set-theoretical class
constant like 'sum', but instead a symbol with arguments and a bound
variable, analogous to indexed union df-iun.  In particular, its
soundness verification, while still simple, is not as "trivial" as with
new class constants.  There is nothing wrong with this in principle,
but it is contrary to my simplicity goal of introducing only new class
constants for new definitions, thus keeping the number of "primitive"
syntactical structures to a bare minimum.  But in this case I think
practicality will win out.  The proofs should be more elegant with
'sumNEW' (later to be changed to 'sum' if I decide to keep it),
and I also think it is more readable.

Of course, soundness justification will not be an issue with the
eventual Ghilbert version.

To further elaborate on my simplicity preference (for which df-fsumNEW
will be an exception), below I reproduce my response to an email Josh
Puritan wrote me (on Oct. 18) regarding the notation for fzvalt.

  > Consider using square brackets for 'compatibility' with the
  > distinction between a closed and open interval.

My response:

  I understand what you are getting at, but there is a slight problem.
  df-fz is just the class symbol "..." which is used as an operation,
  and the parentheses are just the normal parentheses that surround an
  operation value.  Thus "( 1 ... 3 )" means "( ... ` <. 1 , 3 > )".

  I could define a new syntactical structure or pattern "[ A ... B ]" but
  then I couldn't use all the equality, hb*, etc. theorems we have for
  operation values.  After basic set theory development, which is more or
  less finished, I've been trying to introduce only new class constant symbols
  (with exceptions for a few very common things like the unary minus "-u";
  actually that is the only exception so far).  In addition to allowing us
  to reuse general-purpose theorems, the soundness justification is
  trivial for a new constant class symbol, which is what I like most about
  that approach.

  Also, "( m ... n )" is really more of a discrete, unordered list
  than an a continuous closed interval.

  I will probably never be completely happy with "..." in particular
  because it is nonstandard and unfamiliar, but on the other hand it has
  turned out to be very useful for theorems involving finite sums.  But I
  didn't consider it so important that it justifies its own new
  syntactical pattern.  It is so rare in the literature (if it ever
  occurs) that I was pleased to stumble across Gleason's partial version
  of the notion.

  For the four real intervals (x,y), (x,y], [x,y), [x,y] I haven't decided
  what to do yet.  It would be preferable to have them be just operation
  in the form of new class constant operation symbols, but I haven't
  thought of any good notation to accomodate them in this form.  We could
  have e.g.  "(.,.]" or "(]" so we'd have "( A (.,.] B )" or "( (.,.] ` <.
  A , B >. )" or "( A (] B )" etc. but these are odd-looking.  What I will
  end up doing is very open at this point.  Maybe it's time to start using
  words like "closed", "rclosed", "lclosed", "open", etc. in some way?

  Right now we have only the two workhorses "( F ` A )" and "( A F B )"
  for general function/operation values.  Analogously we have "A e. R" and
  "A R B" for predicates/binary relations.  They are the only general
  patterns the reader has to be familiar for virtually all new
  definitions.  In theory these are all that we need, although certain
  notations become very awkward (e.g. extending them to more arguments via
  ordered pairs, and the real intervals you have brought up).

Note that right now, we are using the "workhorse" ( A F B ) for
virtually all of the new definitions of sums, sequences, shifts,
sequential integer sets, etc.  I like it because there is only one
underlying notation, i.e. operation value, that you have to be aware of.
But I think the present df-fsum stretches the limit of what is
practical and "user-friendly".

--------------------

(24-Oct-05) Today we introduce the superior limit limsup, which will
be one of our principal uses of the extended reals.


(22-Oct-05) It appears I mispoke yesterday when I said "The new syntax
allows LALR parsing," and I changed it to "The new syntax moves us
closer to LALR parsability."  From Peter Backes:

  It makes it more LALR than before, but not completely. ;)

  What remains is

    1) set = set (trivial, since redundant)      [i.e. weq vs. wceq]
    2) set e. set (trivial, since redundant)     [i.e. wel vs. wcel]
    3) [ set / set ] (trivial, since redundant)  [i.e. wsb vs. wsbc]
    4) { <. set , set >. | wff } (we already discussed it and agreed it
    was not easy to solve)                       [i.e. copab]
    5) { <. <. set , set >. , set >. | wff } (ditto)   [i.e. copab2]

These are all easy to fix by brute force (eliminating weq, wel, and wsb,
and changing "{", "}" to "{.", "}." in copab and copab2) but I don't
want to be too hasty and am looking into whether there are "nicer" ways
to do this first.


(21-Oct-05) A big change (involving about 121 theorems) was put into the
database today:  the indexed union (ciun, df-iun) and indexed
intersection symbols (ciin, df-iin) are now underlined to distinguish
them from ordinary union (cuni, df-uni) and intersection (cint, df-int).
Although the old syntax was unambiguous, it did not allow for LALR
parsing of the syntax constructions in set.mm, and the proof that it was
unambiguous was tricky.  The new syntax moves us closer to LALR
parsability.  Hopefully it improves readability somewhat as well by
using a distinguished symbol.  Thanks to Peter Backes for suggesting
this change.

Originally I considered "..." under the symbol to vaguely suggest
"something goes here," i.e. the index range in the 2-dimensional
notation, but in the end I picked the underline for its simplicity (and
Peter prefered it over the dots).  Of course I am open to suggestion and
can still change it.  In the distant future, there may be
2-dimensional typesetting to display Metamath notation (probably
programmed by someone other than me), but for now it is an interesting
challenge to figure out the "most readable" 1-dimensional representation
of textbook notation, where linear symbol strings map 1-1 to the ASCII
database tokens.

iuniin is the same as before but has an expanded comment, and also
illustrates the new notation.

(18-Oct-05) Today we show a shorter proof of the venerable theorem id.
Compare the previous version at http://de2.metamath.org/mpegif/id.html .

fzvalt is the same as before but has an expanded comment.

(15-Oct-05) Definition df-le was changed to include the extended reals,
and df-le -> xrlenltt -> lenltt connects the new version to the existing
theorems about 'less than or equal to' on standard reals.

(14-Oct-05) The set of extended reals RR*, which includes +oo and -oo,
was added, with new definitions df-xr, df-pinf, df-minf, and df-ltxr.
The old < symbol was changed to <_RR, the new df-ltxr symbol was called
<, and the ordering axioms were reproved with the new < symbol (and they
remain the same, since in RR, < and <_RR are the same by ltxrlt.  This
allows us to use all remaining theorems about RR in the database
unchanged, since they are all restricted to elements of RR.  The
theorems proved today are the minimum necessary to retrofit the database
in this way.  I was pleasantly surprised at how easy it was to add in
the extended reals.

Unlike textbooks, that just say +oo and -oo are "new" distinguished
elements without saying what they are, we must state concretely what
they are in order to use them.  So I picked CC for +oo and { CC }
for -oo.  Many other choices are possible too.  The important thing
is not what elements are chosen for them, but how the new < ordering
is defined.

Unlike some analysis books, Gleason finds it unnecessary to extend the
arithmetic operations (only the ordering) for +oo and -oo, so I will be
avoiding that too unless a clear advantage becomes apparent.  E.g. some
books define +oo + A = +oo, A / +oo = 0, etc. but for us that is now
undefined.

(6-Oct-05) modal-b is analogous to the Brouwer modal logic axiom if we
map "forall x" to box ("necessarily") and "exists x" to diamond
("possibly").  See http://plato.stanford.edu/entries/logic-modal/ and
also http://www.cc.utah.edu/~nahaj/logic/structures/systems/s5.html

In fact, our axioms ax-4, ax-5, and ax-6 (plus ax-1/2/3, modus ponens,
and generalization) are *exactly* equivalent to modal logic S5 under
this mapping!  This was not intended when I first came up with the
axioms.  Our axioms have a different form because I arrived at them
independently when I didn't know what modal logic was, but they (or
Scott Fenton's ax46/ax-5) are provably equivalent to S5 and can be used
(under the mapping) as alternate axioms for S5.  Conversely, all the
theorems of S5 will automatically map to theorems of our "pure"
predicate calculus.

Axiom ax-7 has no modal logic analog, since it has two variables.
However, if we restrict x and y to be distinct, it might be possible to
make an analogy between it and the Barcan Formula BF (see the
plato.stanford.edu page), particularly because the BF converse is also
true (http://plato.stanford.edu/entries/actualism/ltrueCBF.html) as it
also is for ax-7.

(4-Oct-05) ser1f0 - The difficulty of proving this "obvious" fact was
surprising.

(30-Sep-05) df-isum is a new definition for the value of an infinite sum
that will eventually replace df-sumOLD.  Its advantage is that the sum
can start at any index N instead of the fixed index 1.  isumvalt is the
first use of the new definition.

The notation of df-isum perhaps isn't as nice as df-sumOLD, but I don't
know how else to do it since we are using a linear notation with no
subscripts.  (The infinity superscript is not a separate symbol but part
of the fixed infinite summation symbol, represented as "sumoo" in the
database.)

(27-Sep-05) The obsolete definitions df-seq0OLD and df-climOLDOLD, along
with all theorems dependent on them, have finally been purged from the
set.mm database, lightening it a bit.

dfseq0 is nice.  Perhaps I'll interchange df-seq0 and dfseq0 some day.

(19-Sep-05) Scott Fenton found a shorter proof of ax46.

(18-Sep-05) It is becoming apparent that the recently introduced new
version of df-clim (now called df-climOLDOLD), although very useful
because of its arbitrary starting point, has some limitations:  since
there is no built-in requirement that the limit be a complex number or
that the sequence have complex values, additional conditions would have
to be stated for proving convergence that will make a lot of theorems
awkward.  Therefore I changed the definition to today's df-clim, called
the old ~~> as ~~>OLDOLD, and we will reprove most or all of the old
theorems then delete them.  The new definition df-clim is more complex
but it should be worth it in the end.

(There is still df-climOLD, which is severely limited to sequences
starting at 1, that must eventually be replaced with df-clim.  This will
be a longer-term project, since df-clim is directly or indirectly
affects around 500 theorems.  df-climOLDOLD, with its short-lived
existence, only affects around 20 theorems.)

(14-Sep-05) elfz4b shows the converse of elfz4t also holds - a nice
surprise.  Maybe I'll use it instead of elfz4t.

(11-Sep-05) Today we introduce an new definition, df-uz.  The idiom "set
of all integers greater than M" keeps recurring, so I decided to add a
notation for it to shorten proofs, even though it is nonstandard.  "ZZ
subscript >=" is a function that maps an integer to the set of all
integers greater than or equal to it.  I think I chose a good notation
for it that should be easy to remember; if you don't think so let me
know.

(8-Sep-05) fsumserz is an important theorem that expresses a finite sum
as a partial sum of a sequence builder.  In fact, it shows that the
finite sum notation is redundant, although we'll keep it because it
slightly more compact and seems like a more natural notation.

(7-Sep-05) A small change was made to df-fz to restrict its domain to
ZZ X ZZ, requiring a new version of fzvalt.  All other theorems remain
compatible, but the change allows us to state the useful elfz7t, where
(provided N is a set) we can deduce that M and N are in ZZ simply from
the fact that ( M ...  N ) has a member.  This will allow us to simplify
proofs by not requiring M e. ZZ and N e. ZZ as additional hypotheses.
(The fact that N must be a set is an artifact of our operation value
definition.  I'm currently pondering changing the operation value
definition so that N would not be required to be a set in elfz7t, but
that would be a huge change throughout the db - perhaps in the long term
future.)

seq0seqz and seq1seqz are yesterday's promised special cases of "seq".

(6-Sep-05) The old symbol "seq" for a 1-based infinite sequence builder
has been changed to "seq1" (df-seq1) for consistency with the 0-based
version "seq0".  The symbol "seq" (df-seqz) has been (re)defined to be
an infinite sequence builder with an arbitrary starting index, and we
will show, today or tomorrow, that "seq0" and "seq1" are special cases
of it.

(26-Aug-05) I didn't like the notation for finite sums so I decided to
do it all over again.  Everything in the last few days has been renamed
to *OLD.  These will be reproved with the new notation and the *OLDs
deleted.  (Also, I extended the definition so the value is zero if the
lower limit is greater than the upper limit, like some books do.)

So, instead of the (to me) awkward "F Sigma <M,N>" for

                ---   N
                \          F_i
                /
                ---  i = M

we now can state this as "Sigma`<<M,N>,F>", which seems more natural.
By df-opr this is equivalent to "<M,N> Sigma F", which results in
shorter proofs, so that's what I'll use for most proofs.  But that's
just a technicality that has nothing to do with the definition; anyone
can trivially reprove them with the "Sigma`<<M,N>,F>" notation if they
want.

(20-Aug-05) Many new or revised definitions today:

df-shft replaces df-shftOLD and df-shftOLDOLD - I extended it to all
    complex numbers, not just integers, for more flexible long-term use.
df-clim replaces df-climOLD - Convergence is now independent of the
    domain (NN, NN0, ZZ) of the underlying sequence - much nicer!
    In fact the input function can be garbage at the beginning, as
    long as there exists an integer somewhere beyond which it behaves.
df-seq0 replaces df-seq0OLD and df-seq0OLDOLD in order to use the new
    df-shft
df-fsum is the definition of a finite series summation.  I have mixed
    feelings about the notation (see fsumvalt comment), and comments are
    welcome.
df-plf is the addition of two functions.  I made it so it can apply to
    complex functions in general, not just sequences.  For sequences,
    we'll restrict the function sum to NN, etc. to strip out meaningless
    values.
df-muf multiplies a constant times a function, again for complex functions
    in general.

Slowly the obsolete *OLD versions will be replaced and eventually
deleted.  Yesterday's shftcan1t, etc. are already obsolete!

The lesson learned from the multiple versions of df-shft was that it
seems more useful to keep the definitions simple and as general as
possible.  Individual theorems can impose the necessary restrictions as
needed, rather than having the restrictions "hard-coded" into the
definition.  For example, df-clim is now dramatically more useful by
not restricting the domain of the underlying sequence to NN.

-------

I am thinking about a general 'seq' recursive sequence generator with an
arbitrary starting point.  The present 'seq' would be renamed to 'seq1'.
What would be nice would be:

    ( + seq0 F ) = ( + ( seq ` 0 ) F )
    ( + seq1 F ) = ( + ( seq ` 1 ) F )  etc.

Unfortunately seq0 and seq1 are proper classes and can't be produced as
function values, but restricting them to be sets would limit their
usefulness.  On the other hand, defining seq so that

    ( + seq0 F ) = ( < + , 0 > seq F )

or

    ( + seq0 F ) = ( + seq < F , 0 > )

or

    ( + seq0 F ) = ( < + , F > seq 0 )

etc. can be made to work without a restriction but none of the 12
possibilites seem natural to me.  What do you think?

(17-Aug-05) cvgratlem1,2,3 will replace the longer old versions (renamed
*OLD) in a re-proof of cvgrat that I have planned.

(5-Aug-05) The old definitions of the shift and seq0 operations have
been SCRAPPED.  They have been renamed df-shftOLD and df-seq0OLD (to be
deleted eventually), and replaced by new ones df-shft and df-seq0.  All
of the old theorems are obsolete and have been renamed *OLD.  The old
symbols have been changed to prevent accidental re-use.

The new definitions will provide simpler and more general theorems.  For
example, seq01 and seq0p1 are now the exact analogs of seq1 and seqp1 -
compare seq01OLD and seq0p1OLD, which required an annoying functionality
hypothesis.

(31-Jul-05) Per a suggestion from Scott Fenton, I renamed the following
theorems:

  Old       New

  syl34d    imim12d
  syl4d     imim2d
  syl3d     imim1d
  syl34     imim112i
  syl4      imim2i
  syl3      imim1i
  syl2      imim2
  syl1      imim1

(27-Jul-05) I was finally able to find a shorter proof of uzind.
Veteran visitors to this site will recall the 3/4 megabyte proof
described on 18-Jun-04 in mmnotes2004.txt, then called zind, and
currently renamed to uzindOLD.

(11-Jul-05) Back to the drawing board...  I decided to change binary
coefficient df-bc so that it is now defined (as 0) outside of its
"standard" domain of 0 <_ k <_ n, as is often done in the literature.
With the old definition, I can now see that many proofs using it would
have been very awkward.  Accordingly, several proofs were changed to
accomodate the new definition (not shown on the 'most recent' page - I
usually do not re-date modified proofs) and today's new ones were added.

(6-Jul-05) peano2re, although it is trivial and seems silly, shortens a
dozen proofs and reduces the net size of the set.mm database file.

(5-Jul-05) peano5nn is a simplification of the previous version.  df-n
was also simplified.

(28-Jun-05) pm4.83 finally completes the entire collection of the 193
propositional calculus theorems in Principia Mathematica.  This had been
done before for the Metamath Solitaire applet in
http://us2.metamath.org:8888/mmsolitaire/pmproofs.txt - but the set.mm
proofs are hierarchically structured to be short, indeed as short as I
(or Roy Longton for some of them) could find.

An ordered index of these can be found on the xref file
http://us2.metamath.org:8888/mpegif/mmbiblio.html in the
[WhiteheadRussell] entries.

(26-Jun-05) Yesterday's reuunixfr probably ranks among the most cryptic
in the database.  :)  Today's reuunineg shows an application of it that
is much easier to understand, with most of the confusing hypotheses of
reuunixfr eliminated.

(21-Jun-05) rabxfr lets us conclude things like the following:
(z e. RR -> (z e. {x e. RR | x < 1} <-> -z e. {y e. RR | -y < 1})).
The first two hypothesis just specify that y mustn't be free in B and C
(a less strict requirement than distinct variable groups y,B and y,C).

pm4.42 is Roy Longton's first Metamath proof.

(20-Jun-05) shftnnfn and shftnnval show the example of NN shifted to NN0
described in df-shft.  Hopefully these two theorems make it clear, in
a simple and intuitive way, what the 'shift' operation does.

(19-Jun-05) df-shft is a new definition; see its comment for an
explanation of the sequence shift operation.  In general I dislike
introducing a made-up explicit notation for a concept that exists in the
literature only implicitly in informal proofs, and I try to avoid it
when possible, because the notation will be completely unfamiliar even
to mathematicians.  But in the case of df-shft, after careful
consideration I felt the benefits will outweigh this disadvantage.  Once
the initial complexity is overcome with some basic lemmas, it is a
relatively simple concept to understand intuitively.

(18-Jun-05) We will start using j,k,m,n for integer set variables and
J,K,M,N for integer class variables.  I hope this will improve
readability a little.  Over time I will retrofit old theorems.  This
will be a major change involving hundreds of theorems, so if you have
comments on this let me know.

In the retrofitted proof of bcvalt, you can see the effect of this
change.

(17-Jun-05) imret provides us with a simpler way to define the imaginary
part, compared to df-im.  I may do that eventually.

(11-Jun-05) I finally caved in and revised df-exp so that 0^0=1 (as
can be seen with expnn00) instead of being undefined.  I have decided
that otherwise, some future things I have in mind are just going to be
too awkward.

Raph Levien came up with the original df-exp, where 0^0=1.  But he's a
computer scientist.  From a more purist perspective, I felt it was an
"inelegant patch," as it has been called, and I changed his definition
to exclude it.  For the past year we've trodded along merrily without
it.  But I'm starting to see that 0^0=1 will lead to simpler proofs and
statements of theorems in many cases.  So now we have 0^0=1 again.

Gleason's book defines 0^0=1 and uses it extensive, e.g. in the
definition of the exponential function (where we avoided it by breaking
out the 0th term outside of the infinite sum).

For a further discussion of this see:
http://www.faqs.org/faqs/sci-math-faq/specialnumbers/0to0/

Another reason I wanted to avoid defining 0^0 is that years ago on
Usenet, and probably still, there were endless arguments about it.  I
wanted to distance Metamath from that.  :)

(10-Jun-05) The choose function df-bc was added.  The literature
uses math italic capital C - but that conflicts with our purple C for
classes (when printed on a black-and-white printer).  So I decided to
use a Roman C.

bcvalt is somewhat awkward to prove because of its "Pascal triangle"
restricted domain instead of the full NN0 X. NN0.  Thus we have to use
oprabvali instead of the more efficient oprabval2.

(4-Jun-05) As far as I know, inf5 has never been published.  I think it
is neat.

pm2.13 seems like a rather silly variant of excluded middle (exmid).
What can I say - I'm just implementing what's in the book.

(2-Jun-05) efclt makes use of (in efcltlem1) the very important and
useful ratio test for convergence, cvgrat of 28-May-05, to show (in
efcltlem3) the convergence of the exponential function.  This in turn
lets us show that the value of the exponential function is a complex
number.  This will open a lot of doors with what we can do with the
exponential function.  Note that all of the confusing (or at least
unconventional) limit, seq, and infinite sum stuff have disappeared,
having served their purpose, and we're back into familiar territory.

Interestingly, the bounds we found earlier for Euler's constant e, in
ege2le3, didn't require all this work.  That is because e is a special
case of the exponential function that is much easier to work with.

(27-May-05) sercj tells us the the complex conjugate of each term in an
infinite series is the sum of the complex conjugates of the underlying
sequence.  We prove it by induction.  Recall that (+ seq F)`A means

                ---   A
                \         F_i
                /
                ---  i = 1

Theorem minusex just says that the negative of any class whatsoever
(even a proper class) is a set.  While this is not very meaningful when
the argument is not a complex number, it saves the effort of proving
that the argument is a complex number, making it trivial, for example,
to eliminate the hypothesis "A e. V" of yesterday's cvgcmp3cet.

(26-May-05) cvgcmp3cet is a pretty massive application of the Weak
Deduction Theorem http://us.metamath.org/mpegif/mmdeduction.html that
converts 8 hypotheses into antecedents.  A number of tricks were
employed to make the proof sizes manageable.  I didn't bother with the
final hypothesis, "A e. V", because it's trivial to eliminate with
vtoclg if needed (you don't need the Weak Deduction Theorem for that)
and in most cases A will exist anyway.

(25-May-05) The theorems expgt1t and oewordri have little to do with
each other.  There is an isomorphism between finite ordinal
exponentiation and exponentiation of the natural number subset of reals,
that could be exploited in principle, but they are independently
developed in our database.  A common root for both can be traced back to
ordinal multiplication (which is a starting point for the construction
of the reals), but from that point they diverge.  And when ordinals get
into the transfinite, the behavior of exponentiation becomes bizarrely
different, as we will see when (hopefully) I eventually get to it.

(24-May-05) Two of the hypotheses of cvgcmp3ce, cvgcmp3ce.4 and
cvgcmp3ce.7, are theoretically unnecessary.  However, eliminating them
is tedious (it involves dinkering around in the hidden regions of F and
G prior to index B; these regions were purposely left undefined to make
the theorem more general) and for most practical purposes unnecessary,
so I decided to leave the theorem "less than perfect," so to speak, at
least for now.

We could also, with only a few more steps (by changing y to a dummy
variable z and using cbvexv and mpbi at the end) eliminate the
requirement that x and y be distinct variables.  I may do this if it
ever becomes useful to do so.  In that case, the distinct variable group
"x,y,G" would split into "x,G" and "y,G".

The new rcla4 series swaps the antecedents.  I think this makes their
use more natural in a lot of cases.  However, I'm wondering if this was
a mistake:  rcla4v was used in around 90 theorems, and it took several
hours just to convert a couple dozen of the easiest ones.  In maybe 75%
of those cases the proof size was reduced, but in others it was
increased, and the hoped for net "payback" in terms of reduced database
size hardly seems worth it, if there will be a net reduction at all.
The old rcla4* versions were renamed with an "OLD" suffix, and I'll be
eliminating them over time (on dreary days when I'm feeling otherwise
uninspired).

By the way here is an informal breakdown of the cryptic name "rcla42v":

  'r' - uses restricted quantification (vs. "cla4*")
  'cl' - deals with substitution with a class variable
  'a4' - an analog to the specialization axiom ax-4 (and Axiom 4 in
         many systems of predicate calculus, which is stdpc4 in our
         database)
  '2' - deals with two quantifiers
  'v' - distinct variables eliminate the hypothesis that occurs in rcla4

(21-May-05) eqtr2t and eqtr3t were added because they shortened 16
proofs, with the net effect of reducing the total database size.

(20-May-05) odi is essentially the same proof as the 2/3 smaller nndi
for natural numbers, except that it uses transfinite induction instead
of finite induction.  So we have to prove not only the 0 and successor
cases but also the limit ordinal case.  But the limit ordinal case was a
monstrosity to prove, taking up 2/3 of the proof from steps 59 through
257.  Eventually I'll shorten nndi as a special case of odi.

(16-May-05) drex2 is part of a cleanup of some old lemmas.  The notable
feature of this theorem and others like it is that x, y, and z don't
have to be distinct from each other for the theorem to hold (normally, z
can't occur in the antecedent, as in for example biexdv).  The
"Distinctor Reduction Theorem" provides a way to trim off unnecessary
antecedents of the form (not)(forall x)(x=y), called "distinctors," in a
system of predicate calculus with no distinct variable restrictions at
all (which makes automated proof verification trivial, like for
propositional calculus).  (That system is the same as ours minus ax-16
and ax-17.  The paper shows that it is complete except for antecedents
of the form (not)(forall x)(x=y).  To translate its theorems to standard
predicate calculus, these antecedents are discarded and replaced with
restrictions of the form "x and y must be distinct variables.")

We can also translate distinctors to distinct variable pairs in the
logic itself (after ax-16 and ax-17 are added) by detaching them with
dtru.

The reverse can be done (distinct variable pairs to distinctors) by
using dvelim.  This comes in handy when a distinct variable restriction
is unnecessary, e.g. x and y in ralcom2; we convert the distinct variable
pair to a distinctor with dvelim then eliminate the distinctor with the
algorithm of the Distinctor Reduction Theorem.

(13-May-05) Thank goodness caucvg is out of the way...  The lemmas just
seemed to grow bigger and bigger as I scrambled to complete it and is
quite a mess towards the end.  When the proof author said "this
direction is much harder" he/she is not joking.  There is often much
hidden detail you end up discovering, that isn't apparent at first, when
you try to formalize a proof.  (For example, the very first stumbling
block was how to formalize "the set of numbers less than all values of F
except for finitely many".  Certainly "finitely" isn't to be taken
literally, i.e. strictly less equinumerous than omega, unless we want an
incredibly complex proof.)

It looks like I should eventually introduce an abbreviation for Cauchy
sequences, like I do for Hilbert space.  Then these proofs can be redone
with a somewhat simplified notation.  (That's easy to do, once you have
the proof.)

(12-May-05) For the caucvg proof, I am formalizing the proof found at
http://pirate.shu.edu/projects/reals/numseq/proofs/cauconv.html . I
couldn't find this proof in a textbook (most of those proofs use "lim
sup" instead).  If someone has a textbook reference for this particular
proof, it will be appreciated.

cruOLD has been phased out.

(11-May-05) cru generalizes the old version (now called cruOLD until it
is phased out) to include the converse.

(10-May-05) relimasn is a version of imasng that doesn't require that A
be a set (in the case where R is a relation, which is most of the time).
When A is not a set, the theorem isn't really meaningful - both sides of
the equality become the empty set - but relimasn allows us to prove more
general theorems overall.

(9-May-05) This morning a correspondent wrote me:

> Do you know of a rigorous formulation of Wang's single axiom schema for
> first order identity theory? I saw one in Copi's 'Symbolic Logic [Fourth
> Edition]' page 280, but I don't quite follow his notation nor do I see how
> to precisely state the stipulations for the variables in a "phi and psi"
> style axiom schema. And I didn't see it in your proof explorer as a theorem.

I added sb10f and answered:

I have the 5th edition, and I think you mean P6 of system RS_1 on p.
328.  (The 5th ed. added a chapter on set theory, which moved all the
later pages up, probably by 48 pages or so.  Copi was noted for killing
the used-book market by releasing new editions every few years.)

In the way it is stated, this axiom apparently has 2 errors.  First,
there are no restrictions (that I could find) stated for Fx and Fy.  Let
us suppose Fz is x=z.  Then Fx is x=x and Fy is x=y.  Putting these into
P6, we get:

   A. y (Fy <-> E. x (x=y /\ Fx))
   A. y (x=y <-> E. x (x=y /\ x=x))
   A. y (x=y <-> E. x (x=y))
   A. y (x=y <-> true)
   A. y (x=y)

The last line is false in a universe with 2 or more elements, so the
system is inconsistent.

The correction is to add a proviso that x must not occur free in Fy.

The second mistake is that there is no requirement (that I could find)
that x and y must be be distinct variables.  But if they are not
distinct, an inconsistent system results.

With these corrections, the proofs of the usual axioms on p. 329 still
go through.

The "A. y" prefix is redundant in P6, since it can be added by R2
(generalization).  In a logic that allows an empty universe, the A. y
would be needed, but on p. 319 it is stated that RS_1 is intended to be
true in a nonempty universe (and the rest of the axioms won't work in an
empty universe).  So, it seems like R6 is an afterthought tacked onto
the system.  Even the notation Fx and Fy is different from the Q that
represents the substitution instance of P in earlier axioms e.g. P5
p. 294.

I added what I thought was a close approximation to P6 (without the
redundant quantifier) here:

  http://us2.metamath.org:8888/mpegif/sb10f.html

The hypothesis specifies that x must not occur free in phi, and x and y
must be distinct, as must necessarily be the case.

Three other variants that are similar to P6 are:

  http://us2.metamath.org:8888/mpegif/sb5.html
  http://us2.metamath.org:8888/mpegif/sb5rf.html
  http://us2.metamath.org:8888/mpegif/equsex.html ,

the last one implicitly substituting y for x in phi to result in psi.

By the way, even though we can express a logical equivalent to P6 in
Metamath, this does not mean that it becomes the sole axiom replacing
the other equality/substitution axioms.  (It is possible that one or
more of the others could become redundant, but I haven't thought about
it too much.)  The reason is that in RS_1, substitution is done at the
metalogical level, outside of the primitive system.  In Metamath, we do
this "metalogic" at the primitive level of the system itself, and we use
additional axioms involving equality to accomplish this.  In many ways
substitution and equality are closely related, and the standard
formalization "hides" this by moving substitution outside of the axioms.

You might want to re-read these that explain this in more detail:

  http://us.metamath.org/mpegif/mmset.html#axiomnote
  http://us.metamath.org/mpegif/mmset.html#traditional


(8-May-05) While Euclid's classic proof that there are infinitely many
primes is easy to understand intuitively, I found the proof used by
infpnlem1 and infpnlem2 simpler to formalize.  (Specifically, this proof
avoids the product of a hypothetical finite set of all primes, which I
found cumbersome to formalize.)

Here is the proof:

  For any number n, the smallest divisor (greater than 1) of n!+1 is a
  prime greater than n.  Hence there is no largest prime.

Or, in explicit detail:

  Suppose there are a finite number of primes.  Let p be the largest.  Let
  q be the smallest divisor (greater than 1) of p!+1.  (The set of
  divisors of p!+1 is nonempty, since p!+1 is one of them, so by the
  well-ordering principle there is a smallest, which we will call q.)  Then
  none of 2,3,4,...,p divides q since otherwise it would also divide
  p!+1, which is impossible.  (2,3,4,...,p all divide p!, so none divides
  p!+1.)  And none of p+1,...,q-1 divides q since otherwise it would also
  divide p!+1, and then q would not be the smallest divisor of p!+1.
  Therefore q is prime, and q > p, so p is not the largest prime.

(6-May-05) funcnvres2 is a tongue-twister, or perhaps a brain-twister...

I reproved cvgcmp as a special case of cvgcmp2.  However, I have
(temporarily?) left in the original proof and called it cvgcmpALT, as I
think it might be instructive.  Comparing cvgcmpALT to
cvgcmp2lem+cvgcmp2, i.e. 33 vs. 68+17=85 steps, you can see how much
extra work was needed just to ignore up to the Bth term in cvgcmp2.

(5-May-05) cvgcmp2c is useful because it allows the test function
to be much larger (via a large C) than the reference function, yet
still converge.

(4-May-05) divclt, divrect, redivclt are slight modifications of their
older versions, which have been renamed divcltOLD, divrectOLD,
redivcltOLD and which will disappear when they are phased out over time

(3-May-05) prodgt0t also works for A=0, not just A strictly greater than
0.  This makes the theorem more general - something I like to do when I
can - but requires more work.  In prodgt0 (from which prodgt0t is
derived with dedth2h) you can see the separate derivation that we need
for the A=0  case.

(2-May-05) reccl* and rereccl* shorten many proofs (by replacing explicit
division closure that was used before) - e.g. I shortened 18 proofs
with rereccl.  So even though these are trivial they were worth adding.

(1-May-05) cvgcmp2 will be used to build a general-purpose comparison
test for complex number sequences.  cvgcmp2 tests for convergence of a
nonnegative real infinite series (+ seq G) (which normally will be a
series of absolute values), which is compared to a known convergent
series (+ seq F).  This version of cvgcmp allows us to ignore the
initial segment up to the Bth term; this was a tricky thing to do.  To
achieve this I compare G to an auxilliary sequence H (see cvgcmp2lem)
instead of F; H adds the supremum of the initial segment of G to F, so
it is guaranteed to be bigger than G everywhere including the initial
segment.

Originally I planned to use climshift of 24-Apr and sertrunc of 27-Apr
to achieve this (the ignoring up to the Bth term); now it looks like
they are no longer needed.  Too bad; they were a lot of work.  Perhaps
I'll leave them in in case a use for them shows up in the future.

In cvgcmp2 we show the actual value it converges to (i.e. the sup)
rather than just existence.  This will allow us to use hypotheses
instead of antecedents, which will make some proofs smaller.  For our
final theorem we will eliminate the hypotheses with the Weak Deduction
Theorem dedth then produce a simpler-to-state existence version.

(24-Apr-05) 2eu8 is a neat little discovery that I doubt has ever been
published.  It is fun seeing what you can do with the E! quantifier.
Hardly anything about it exists in the literature, and apparently double
E! has never even been published correctly; see 2eu5.  Exercise:  Can
you change E!x E!y to E!y E!x in either side of 2eu8 by using 2eu7 as
suggested?  (Hint:  use ancom.)  Note that E!x E!y doesn't commute
generally, unlike Ex Ey; probably not too many people know that.
Another interesting thing about 2eu7 and 2eu8:  x and y don't have to be
distinct variables.

(23-Apr-05) climshift shows that we can ignore the initial segment of a
sequence when computing the limit.  This is intuitively obvious (since
it's only what happens towards infinity that counts) but is a little
tedious to prove.

(22-Apr-05) It is curious that max1 doesn't require B to be a real
number.

(21-Apr-05) In steps 1-19 of climre, you may wonder why we have extra
steps using vtoclga to switch from variable x to variable w, when in
fact variable x could have been used throughout up to step 19.  The
answer is that by using w's, we can reuse step 14 at step 43, without
having to repeat its work.  This is a little trick that shortens the
compressed proof and the web page.  (The uncompressed proof, on the
other hand, is lengthened because it does not reuse previous steps, but
normally set.mm is stored with compressed proofs.)

(20-Apr-05) For serabsdif, note that (+ seq F)`n - (+ seq F)`m is the
sum from m+1 to n of the terms of F, i.e.
F`(m+1) + F`(m+2) + ... + F`n.  So even though our notation for series
(+ seq F) is limited for notational simplicity to start at the fixed
lower index of 1, we can represent a more general lower limit using
this method.  (A more general notation for series may be introduced in
the future.)

(19-Apr-05) We're going to be using (+ seq F) a lot, so here's a
refresher, since this notation is not standard.  We are using a special
case of our general-purpose "seq" operation, and there seems to be no
standard notation for (+ seq F) in the literature other than the
informal "a_1 + a_2 + ...  + a_n" which is not suitable for formal math.
(Gleason uses "F-" in front of an infinite sum to indicate the partial
sum function underlying the infinite sum, but it is not standard.)  If
you are following these theorems it might be useful to keep the
following note in mind.  It is straightforward if you understand the
correspondence to the conventional notation.

(+ seq F) is the sequence of partial summations in an infinite
series.  E.g. for a sequence of squares:

  argument sequence   partial sum of series

   n         F`n     (+ seq F)`n
   1         1          1
   2         4          5
   3         9         14
   4        16         30
          ...

Of course this series diverges, so the infinite sum doesn't exist, but
all partial summations exist as shown above.  Today's theorem serft
expresses a very obvious fact:  if F is a function from the positive
integers to the complex numbers, then so is (+ seq F).

Another example:

   n          F`n     (+ seq F)`n
   1         0.5        0.5
   2         0.25       0.75
   3         0.125      0.875
   4         0.0625     0.9375
          ...

This series converges to 1, so the infinite sum sigma-1-oo`F exists and
equals 1 (see theorem geosum1).  By "converges" we mean the limit as
n->oo of (+ seq F) is 1; we express this as (+ seq F) ~~> 1 (see theorem
geolim).

(17-Apr-05) ege2le3 proves with absolute rigor that scientific
calculators display the value of e correctly to at least 1 decimal
place. :)  This is a nice "sanity check" of all the abstract stuff that
finally collapses to this result.

(13-Apr-05) It surprised me that it took so much work to prove that
e is a real number.

(5-Apr-05) equid2 shows how you'd prove x=x in a traditional system of
predicate calculus which has a9e as an axiom.  This proof is almost
identical to Tarski's.  Still, I think the no-dummy-variable equid
proof is neat and unexpected.

(1-Apr-05) The Usenet announcement of Poisson d'Avril's theorem is here:
http://groups-beta.google.com/group/sci.logic/browse_frm/thread/7aa9265da2819705/ee8862dd6adb3fad#ee8862dd6adb3fad

(26-Mar-05) geosum1, which you may be familiar with from high-school
algebra, is the culmination of our initial development of infinite
series.  As you can see, it is much harder than the high-school version
if you want to prove it with absolute rigor!

geosum0 shows the sum from 0 to infinity instead of 1 to infinity.  It
provides a good illustration of why I chose to have our "fixed limit"
infinite series operator start at 1 instead of 0, so that we just add
the 0 case outside of the summation when we need a lower limit of 0. If
we started at 0, we would have to worry about the meaning of 0^0 in this
case.  A long time ago, when I introduced the ~~> symbol (mainly for use
with Hilbert space), I initially defined it for functions starting at 0
instead of 1. But I ran into so many special cases (divide-by-0 and so
on) that eventually I redefined it to start at 1. This greatly
simplified many proofs.  Who knows, this may be the real reason that
analysts start with 1 for the natural numbers (unlike set theorists, who
start at 0).  In fact Schechter's _Handbook of Analysis_ doesn't even
have a separate symbol for the set of nonnegative integers; instead he
uses "NN (natural numbers) union {0}" in the one case I could find where
he needed them.

(16-Mar-05) In sumvalt and sumval2t, the function Sigma_1^oo is one
symbol (object), not three symbols, even though it is shown as three as
a mnemonic device.  To make the proofs and notation simpler, the lower
limit is fixed at 1, and even with this constraint it should be useful
in a wide variety of applications.  I chose 1 instead of 0 as the lower
limit because the 0th term often involves messy special cases (e.g. to
avoid divide-by-0), and it's easy enough to add the 0th term outside the
summation when we want.  In addition, our limit relation ~~> is defined
for sequences that start at 1, making it compatible.  (Later we may
introduce a more general summation with variable upper and lower limits,
but that wouldn't buy us a whole lot now and would just make the
notation complex.)  The Sigma_1^oo function has a single argument, which
is an infinite sequence that starts at 1 (i.e. is a function from natural
numbers to complex numbers).  The value of Sigma_1^oo is the infinite
sum of all the numbers in the sequence, if that sum exists.  I thought
the the conventional summation sign would be neat reminder that this is
what the function does, even though it is used slightly differently from
the textbook summation (e.g. there are no dummy index variables; these
are implicit in the sequence that it takes for an argument).

The Sigma_1^oo object is, on the one hand, just a set like any other
set; more specifically it is a set of ordered pairs that gives us a
function of one variable.  But if you think about it, it contains
implicitly an amazingly complex "machine" inside.  It can take in any
infinite sequence whatsoever and produce the infinite sum, if the sum
exists.  If you peel away the layers of its definition, you'll find
df-rdg, our recursive function generator on ordinals.

(14-Mar-05) For sersuc, recall the notes of 7-Mar-05 below.  sersuc
tells us the value of the next partial sum in an infinite series.
Yesterday's ser1 tells us the value of the first partial sum i.e.
F ` 1 .

(9-Mar-05) ltsor arises as part of our complex number construction; it
is needed for the proof of a couple of our complex number axioms.  ltso,
on the other hand, is a result derived from the complex number axioms
after those axioms have been proved.  I got tired of having to clean up
accidental uses of ltsor in place of ltso (which destroys the
portability of our complex number construction), so I decided to prevent
it once and for all by adding the artificial right conjunct.  Clever,
eh?

(7-Mar-05) This is what the 'seq' operation in sercl is all about:
  ( + seq F ) ` 1  =  F ` 1
  ( + seq F ) ` 2  =  F ` 1 + F ` 2
  ( + seq F ) ` 3  =  F ` 1 + F ` 2 + F ` 3     etc.
In other words we are using the powerful 'seq' recursion operation to
create the terms of an infinite series from an arbitrary infinite
sequence F. We will encountering this device frequently as we get into
infinite series.  (With 'times' instead of '+', 'seq' will give us
infinite products.)  Earlier we used 'seq' to define exponentiation
df-exp and factorial df-fac.

By the way, note that in theorem sercl, the class A is normally
dependent on x. In other words, A should be thought of as A(x).  The way
you can tell is that A and x are not both in the same distinct variable
group, yet A is in the scope of x (i.e. inside the braces in the first
hypothesis and in the scope of the quantifier in the second hypothesis).
THIS IS AN IMPORTANT PRINCIPLE THAT CONFUSES SOME PEOPLE.  We also know
that A is _not_ dependent on y because A and y must be distinct.  (On
the other hand, the fact that B and x must be distinct is an irrelevant
artifact resulting from a sloppy proof.  I may improve the proof at some
point to get rid of that unnecessary restriction, unless it lengthens
the proof too much.  Sometimes I leave such artifacts in, especially in
lemmas used once, if it results in a shorter proof as it often does.)

As a background project I'm slowly filling in the remaining
propositional calculus theorems from Principia Mathematica.  I figure we
might as well have the complete collection eventually.

(5-Mar-05) By using brrelexi and the new climrel in the proof of clim,
clim's old "F in V" hypothesis was eliminated.  The new version of clim
also allowed us to prove new versions of the other clim* theorems with
this hypothesis eliminated.  Overall the database size decreased since
theorems referencing clim* no longer have to prove "F in V".

(4-Mar-05) oancom requires the Axiom of Infinity for its proof.
Virtually all other results on ordinal arithmetic, remarkably, do not
require the Axiom of Infinity (which starts being used with theorems
inf4 and after; inf4 currently has the colored number 3567).

(1-Mar-05) alephval3 - I finally figured out how to prove this
convoluted, self-referencing definition that at least two authors prefer.
Even though in some sense it may be "intuitive," it wasn't an easy thing
to prove formally.

(20-Feb-05) Well, I proved that ax0re is redundant as a complex number
axiom, the first redundancy that anyone has found in 8 years.  0re
replaces the old ax0re, and ax0re was removed from
http://us2.metamath.org:8888/mpegif/mmcomplex.html .  0cn is a completely
new proof of the old 0cn that doesn't depend on the old ax0re, and it
provides the key to eventually proving 0re.  The table row on the
mmcomplex.html page, after the grayed-out ax0re axiom label, shows the
connections between the important theorems for the proof.

(18-Feb-05) dfsb2 was one of the two choices I was considering a long
time ago when I finally chose df-sb somewhat arbitrarily.  I decided to
prove dfsb2 as a theorem, well, just to have it proved.  Although the
proof isn't long, it's actually somewhat involved all the way back to
axioms.  Axiom ax-11 seems essential:  ax-11 -> equs2 -> equs5 -> sb4 ->
dfsb2.

By the way it is an open problem whether ax-11 is redundant.  I
can prove from the others all cases of ax-11 where phi is replaced by
any expression without a wff variable e.g. (x=z -> -.w=y).
ddelimf2 was, I felt, a major step towards helping prove the
redundancy of ax-11, but I haven't made any progress since.

(17-Feb-05) I was somewhat surprised hbequid could be proved without
ax-9.  (I found the proof while toying with the open problem of item #16
at http://us2.metamath.org:8888/award2003.html .  That problem is still
unsolved, though.)

(16-Feb-05) dfrdg2 (which uses yesterday's eqif) allows us to introduce
a new definition df-rdg of the rec operation.  The new df-rdg now fits
on one line if you put your browser in full screen mode!  I rewrote the
df-rdg comment slightly.  df-rdg is still almost "impossible" to
understand, but I think the use of the "if" operation improves its
understandability a little.

I cleaned up the list of traditional predicate calculus with equality
axioms at http://us2.metamath.org:8888/mpegif/mmset.html#traditional and
added stdpc6 to match Mendelson's system exactly.

What is very strange is why stdpc6 is quantified.  It is possible this
may make it sound in empty domains to make it compatible with the system
on p. 148, but I couldn't find any indication of this.  Does anyone
know?  If you have the 3rd or earlier (pre-1997) edition of Mendelson's
book, could you check for me that Axiom 6 p. 95 (or the equivalent page)
is quantified?

I renamed sbequ2a from yesterday to become stdpc7 and enhanced its
description.

(15-Feb-05) eqif shows an example of what elimif is intended for.

stdpc7 is a faithful emulation of the 5th traditional axiom
at http://us2.metamath.org:8888/mpegif/mmset.html#traditional and
replaces sbequ2, which wasn't quite right for that purpose.

(13-Feb-05) 2eu6 is nice in that it, unlike 2eu4, only has one mention
of phi on the right-hand side.  This can be useful when phi is a long
expression, so we don't have to repeat it twice.  It also makes less
urgent the need for a rarely-used and nonstandard new definition for
double existential uniqueness such as E!!xy or something, which is
nonexistent in the literature (which incorrectly uses E!xE!y; see 2eu5).
As you can see 2eu6 was somewhat tedious to prove.

(9-Feb-05) axaddopr and axmulopr can't be proved directly from the
axioms for complex numbers shown at
http://us.metamath.org/mpegif/mmcomplex.html , so I had to dig back into
their construction.  Brings back memories - I haven't looked at it
in years.

The construction was not easy, with very tedious equivalence relations
(look at oprec and ecoprass for example) to jump from one level to the
next - positive integers, positive rationals, positive reals (using
Dedekind cuts), signed reals, and finally complex numbers.  Nonetheless
it appeared to be the simplest of several methods I looked at.  The
final axioms are cleanly broken out, so a different construction could
be "plugged in" trivially for anyone who prefers a different approach
(and is willing to go through the tedious construction).

axaddopr and axmulopr will be used for some infinite sequence stuff
because it will make some things slightly simpler.  However, I decided
not to replace the "official" axioms at
http://us.metamath.org/mpegif/mmcomplex.html with these because I think
the official ones look nicer, and in principle they are sufficient.


(8-Feb-05) In flval2t, "U{x in ZZ|...}" can be read:  "The unique
integer x such that..."  (provided there is exactly one such x, which in
this case there is).

(4-Feb-05) The two variations ordsssuc and ordsssuc2 show that either A
or B can be a general Ord class.  However, it fails if both of them are
Ord classes.  In other words at least one of them must exist as a set,
i.e. a member of On.  Of course both may be sets, as shown by the weaker
onsssuc.

ordunisuc2 is one of those neat counterintuitive results - you wonder
what one side of the equivalence could possibly have to do with the
other...

(3-Feb-05) An error made in some published math books for the layman is
the statement that there are aleph-one reals (or irrationals).  In fact,
there are 2^aleph-zero reals, which is equal to aleph-one only when we
assume the Continuum Hypothesis.  Without CH we can only state that
there are at least aleph-one reals (or irrationals), but there could be
more.

To prove aleph1irr we invoke the somewhat exotic infdif.

(31-Jan-05) I realized that onpwsuc could be generalized to all ordinal
classes, not just ordinal numbers, so the result is ordpwsuc.  I also
simplified the proof of onpwsuc so as to derive it trivially from
ordpwsuc.  By the way I mentioned onpwsuc on Usenet; search for
"onpwsuc" in groups.google.com.

(20-Jan-05) alephfp is one of several theorems where we show an explicit
expression, vs. textbooks, which typically show only existence.  To me,
an actual example is a lot more satisfying.  Two other examples in
set.mm are trcl and cardaleph.  The rec function is one of the main
tools that lets us construct explicit expressions.

(19-Jan-05) oev2 is the simplest expression for the "traditional"
definition I could find, using only the rec function and set theory
primitives (without the "if" function of oev).  The left-hand side of
the intersection is the "natural" definition that arises from
transfinite recursion, and the right-hand side suppresses 0^(limit
ordinal) to be 0 instead of 1, while keeping 0^0=1.

(12-Jan-05) Yesterday I suggested proofs from biluk and mpbi as an
exercise.  I looked them up in the _Polish Logic_ book and they are not
obvious at all.  pm4.2 can be proved in 13 steps, but the others are much
longer.  So if you're interested, get the book to avoid a lot of
frustration.

(11-Jan-05) The proof of biass was reduced to 35 steps (with the help of
or42 and xor).

biluk is an easy consequence of biass.  Note that biass, bicom, and
pm4.2 can be derived from biluk and mpbi and nothing else, although we
won't be doing it.  (Exercise for the reader...)

or42 is the 'or' version of an42, which "rotates" the right-most 3
conjuncts.  an42 and an42s are used surprisingly often (for such an
apparently obscure operation).  Other analogues are add42 and caopr42.

(7-Jan-05) tfinds3 can shorten certain proofs that used to use tfinds by
8 steps, which is the number of steps in the proof of tfinds3 from
tfinds.  By applying it to the 5 theorems in its referenced-by list, I
reduced the net size of the set.mm database file (vs. before I added
tfinds3).  In some cases I shortened them more:  compare (until the
mirror site gets refreshed)
http://us2.metamath.org:8888/mpegif/oacl.html (29 steps) vs.
http://us.metamath.org/mpegif/oacl.html (41 steps)

(5-Jan-05) Again, compare oesuc to omsuc to see the additional
complexity caused by the awkward traditional definition.
oelim (compared to omlim) isn't too bad, though.

(4-Jan-05) According to oe0m1, zero to the omega power is zero, not
one.  This is the requirement that complicates df-oexp.

(1-Jan-05) oev is our first theorem involving ordinal exponentiation.
It uses the somewhat awkward traditional definition.  Compare it to omv
for example; an alternate, but nontraditional, definition for
exponentiation would be exactly as simple.  I decided on the current
definition after a discussion here:
http://groups-beta.google.com/group/sci.logic/browse_frm/thread/fac0ce315e8ea855
However it will be making a number of proofs, such as this one, more
complex.

(See http://us2.metamath.org:8888/mpegif/mmnotes2004.txt for older notes.)
